Feature/binary data operation

backend/ibex/core/data_manipulation_methods.py

@@ -0,0 +1,223 @@
+from typing import Optional
+from enum import Enum
+from pydantic import BaseModel
+
+
+class InterpolationMethod(str, Enum):
+    EXACT_VALUE = "exact_value"
+    LINEAR = "linear"
+    NEAREST = "nearest"
+
+
+class SmoothingMethod(str, Enum):
+    GAUSSIAN_FILTER = "gaussian_filter"
+    SAVITZKY_GOLAY_FILTER = "savitzky-golay_filter"
+
+
+class AdditionalParameter(BaseModel):
+    """
+    Parameters for specific data manipulation methods. E.g. sigma -> for Gaussian smoothing
+    """
+
+    name: str
+    human_readable_name: str
+    description: str
+    possible_values: Optional[list[str]] = None
+
+
+class PossibleValue(BaseModel):
+    """
+    Possible value for data manipulation method parameter. E.g. Gaussian smoothing
+    """
+
+    value: str
+    description: str
+    additional_parameters: Optional[list[AdditionalParameter]] = None
+
+
+class DataManipulationParameter(BaseModel):
+    """
+    E.g. interpolate_over, type of filtering, binary operation
+    """
+
+    human_readable_name: str
+    name: str
+    description: str
+    type: str
+    default: Optional[str] = None
+    possible_values: Optional[list[PossibleValue]] = None
+    group_label: Optional[str] = None
+    fields: Optional[list["DataManipulationParameter"]] = None
+
+
+class DataManipulationOperation(BaseModel):
+    """
+    Type of data manipulation method. E.g. data-smoothing, data-interpolation, binary-operation
+    """
+
+    name: str
+    description: str
+    method_parameters: list[DataManipulationParameter]
+
+
+class DataManipulationMethodsResponse(BaseModel):
+    data_manipulation_methods: list[DataManipulationOperation]
+
+
+DataManipulationParameter.model_rebuild()
+available_methods = DataManipulationMethodsResponse(data_manipulation_methods=[])
+
+# ====================== DATA INTERPOLATION ======================
+
+data_interpolation_description = DataManipulationOperation(
+    name="Data interpolation",
+    description="Operation performed in order to represent dataset over different set of coordinates",
+    method_parameters=[],
+)
+
+# ====================== DATA INTERPOLATION PARAMETERS ======================
+
+data_interpolation_interpolate_over_parameter = DataManipulationParameter(
+    human_readable_name="Interpolate over",
+    name="interpolate_over",
+    description="List of URIs to gather coordinates from, for interpolation",
+    type="list[string]",
+)
+
+data_interpolation_method_parameter = DataManipulationParameter(
+    human_readable_name="Interpolation method",
+    name="interpolation_method",
+    description="Method used during data interpolation",
+    type="string",
+    default=InterpolationMethod.EXACT_VALUE,
+    possible_values=[
+        PossibleValue(
+            value=InterpolationMethod.EXACT_VALUE,
+            description="values are present only on data points where they were originally. Rest of the data grid is filled with NaNs",
+        ),
+        PossibleValue(
+            value=InterpolationMethod.LINEAR,
+            description="see scipy.interpolate.RegularGridInterpolator documentation",
+        ),
+        PossibleValue(
+            value=InterpolationMethod.NEAREST,
+            description="see scipy.interpolate.RegularGridInterpolator documentation",
+        ),
+    ],
+)
+
+data_interpolation_description.method_parameters.append(data_interpolation_interpolate_over_parameter)
+data_interpolation_description.method_parameters.append(data_interpolation_method_parameter)
+available_methods.data_manipulation_methods.append(data_interpolation_description)
+
+# ====================== DATA SMOOTHING ======================
+
+data_smoothing_description = DataManipulationOperation(
+    name="Data smoothing/denoising",
+    description="Operation performed in order to eliminate noise from data",
+    method_parameters=[],
+)
+
+# ====================== DATA SMOOTHING PARAMETERS ======================
+
+data_smoothing_method_parameter = DataManipulationParameter(
+    human_readable_name="Smoothing method",
+    name="smoothing_method",
+    description="Method to be used in data smoothing process",
+    type="string",
+    possible_values=[
+        PossibleValue(
+            value=SmoothingMethod.GAUSSIAN_FILTER,
+            description="see scipy.ndimage.gaussian_filter documentation",
+            additional_parameters=[
+                AdditionalParameter(
+                    name="gaussian_smoothing_sigma",
+                    human_readable_name="Sigma",
+                    description="Standard deviation for Gaussian kernel.",
+                )
+            ],
+        ),
+        PossibleValue(
+            value=SmoothingMethod.SAVITZKY_GOLAY_FILTER,
+            description="see scipy.signal.savgol_filter documentation",
+            additional_parameters=[
+                AdditionalParameter(
+                    name="savgol_smoothing_window_length",
+                    human_readable_name="Window length",
+                    description="The length of the filter window (i.e., the number of coefficients). If mode is ‘interp’, window_length must be less than or equal to the size of x.",
+                ),
+                AdditionalParameter(
+                    name="savgol_smoothing_polyorder",
+                    human_readable_name="Polyorder",
+                    description="The order of the polynomial used to fit the samples. polyorder must be less than window_length.",
+                ),
+                AdditionalParameter(
+                    name="savgol_smoothing_deriv",
+                    human_readable_name="Deriv",
+                    description="The order of the derivative to compute. This must be a nonnegative integer. The default is 0, which means to filter the data without differentiating.",
+                ),
+                AdditionalParameter(
+                    name="savgol_smoothing_delta",
+                    human_readable_name="Window delta",
+                    description="The spacing of the samples to which the filter will be applied. This is only used if deriv > 0. Default is 1.0.",
+                ),
+                AdditionalParameter(
+                    name="savgol_smoothing_mode",
+                    human_readable_name="Mode",
+                    description="This determines the type of extension to use for the padded signal to which the filter is applied.",
+                    possible_values=["mirror", "constant", "nearest", "wrap", "interp"],
+                ),
+                AdditionalParameter(
+                    name="savgol_smoothing_cval",
+                    human_readable_name="C-Val",
+                    description="Value to fill past the edges of the input if mode is ‘constant’. Default is 0.0.",
+                ),
+            ],
+        ),
+    ],
+)
+
+data_smoothing_description.method_parameters.append(data_smoothing_method_parameter)
+available_methods.data_manipulation_methods.append(data_smoothing_description)
+
+# ====================== SIMPLE DATA OPERATIONS ======================
+
+simple_data_operations_description = DataManipulationOperation(
+    name="Simple Data Operations",
+    description="Ordered list of scalar operations applied to the dataset. "
+    "Execution order is determined by the order of parameters in the request.",
+    method_parameters=[],
+)
+
+data_operations_parameter = DataManipulationParameter(
+    human_readable_name="Operations",
+    name="operations",
+    description="Ordered list of scalar operations applied to every data point.",
+    type="list[object]",
+    group_label="Operation",
+    fields=[
+        DataManipulationParameter(
+            human_readable_name="Type",
+            name="operation_type",
+            description="Type of operation",
+            type="string",
+            possible_values=[
+                PossibleValue(value="add", description="Addition"),
+                PossibleValue(value="sub", description="Subtraction"),
+                PossibleValue(value="mul", description="Multiplication"),
+                PossibleValue(value="div", description="Division"),
+                PossibleValue(value="pow", description="Exponentiation"),
+                PossibleValue(value="root", description="Nth root"),
+            ],
+        ),
+        DataManipulationParameter(
+            human_readable_name="Value",
+            name="operation_value",
+            description="Scalar value for the operation",
+            type="number",
+        ),
+    ],
+)
+
+simple_data_operations_description.method_parameters.append(data_operations_parameter)
+available_methods.data_manipulation_methods.append(simple_data_operations_description)

backend/ibex/core/ibex_service.py

@@ -3,11 +3,12 @@
 import time
 from pathlib import Path
 from functools import wraps  # for measure_execution_time()
-from typing import Any, Callable, Optional, Sequence, List
+from typing import Any, Callable, Optional, Sequence
 
 from ibex.data_source.imas_python_source import IMASPythonSource
 from ibex.data_source.exception import CannotGenerateUriException
 from ibex.core.utils import IMAS_URI
+from ibex.endpoints.schemas.request_data_schemas import PlotDataRequestModel
 
 
 # helper decorator used during development
@@ -114,21 +115,5 @@ def get_multiple_node_data(uri: str) -> dict:
     )
 
 
-def get_plot_data(
-    uri: str,
-    interpolate_over: List[str] | None,
-    interpolation_method: str | None,
-    downsampling_method: str | None,
-    downsampled_size: int,
-) -> dict:
-    uri_obj = IMAS_URI(uri)
-    return data_source.get_plot_data(
-        uri=uri_obj.uri_entry_identifiers,
-        ids=uri_obj.ids_name,
-        node_path=uri_obj.node_path,
-        occurrence=uri_obj.occurrence,
-        interpolate_over=interpolate_over,
-        interpolation_method=interpolation_method,
-        downsampling_method=downsampling_method,
-        downsampled_size=downsampled_size,
-    )
+def get_plot_data(plot_data_query: PlotDataRequestModel) -> dict:
+    return data_source.get_plot_data(plot_data_query)

backend/ibex/data_source/data_source_interface.py

@@ -1,7 +1,8 @@
 """Interface for all data sources"""
 
 from abc import ABC, abstractmethod
-from typing import Sequence, Optional, List
+from typing import Sequence, Optional
+from ibex.endpoints.schemas.request_data_schemas import PlotDataRequestModel
 
 
 class DataSourceInterface(ABC):
@@ -123,28 +124,12 @@ def list_db_entries(
         """
         ...
 
-    def get_plot_data(
-        self,
-        uri: str,
-        ids: str,
-        node_path: str,
-        occurrence: int = 0,
-        interpolate_over: List[str] | None = None,
-        interpolation_method: str | None = None,
-        downsampling_method: str | None = None,
-        downsampled_size: int = 1000,
-    ) -> dict:
+    def get_plot_data(self, plot_data_query: PlotDataRequestModel) -> dict:
         """
         Returns all data used to plot selected quantity. Result contains data values, metadata and coordinates.
 
-        :param uri: imas URI
-        :param ids: name of ids e.g. core_profiles
-        :param node_path: path to ids node e.g. ids_properties/version_put
-        :param occurrence: ids occurrence number
-        :param interpolate_over: list of uris used in interpolation
-        :param interpolation_method: method to be used in data interpolation; one from scipy.interpolate.RegularGridInterpolator or 'exact_value'
-        :param downsampling_method: one of the downsampling metods returend by :func:`~ibex.endpoints.info.downsampling_methods` endpoint, or None
-        :param downsampled_size: target size of downsampled data
+        :param plot_data_query: See :class:`ibex.endpoints.schemas.request_data_schemas.PlotDataRequestModel`
+        :type plot_data_query: :class:`ibex.endpoints.schemas.request_data_schemas.PlotDataRequestModel`
         :return: Dictionary containing data values, metadata and coordinates.
         """
         ...