darfix 4.2.0__py3-none-any.whl → 4.3.0__py3-none-any.whl

darfix/tasks/datapartition.py

@@ -1,52 +1,10 @@
-from __future__ import annotations
+import warnings
 
-from ewokscore import Task
-from ewokscore.missing_data import MISSING_DATA
-from ewokscore.missing_data import MissingData
-from ewokscore.model import BaseInputModel
-from pydantic import ConfigDict
+from .data_partition import DataPartition  # noqa: F401
 
-from darfix import dtypes
-
-
-class Inputs(BaseInputModel):
-    model_config = ConfigDict(use_attribute_docstrings=True)
-    dataset: dtypes.Dataset
-    """ Input dataset containing a stack of images """
-    bins: int | MissingData = MISSING_DATA
-    """ Number of bins to use for partitioning the data. Default is the number of frames in the dataset."""
-    filter_bottom_bin_idx: int | MissingData = MISSING_DATA
-    """ index of the bins to retrieve bottom threshold filter value. If not defined, no filtering is applied."""
-    filter_top_bin_idx: int | MissingData = MISSING_DATA
-    """ index of the bins to retrieve top threshold filter value. If not defined, no filtering is applied."""
-
-
-class DataPartition(
-    Task,
-    input_model=Inputs,
-    output_names=["dataset"],
-):
-    """
-    Filter frames with low intensity.
-    """
-
-    def run(self):
-        dataset = self.inputs.dataset
-        if not isinstance(dataset, dtypes.Dataset):
-            raise TypeError(
-                f"dataset is expected to be an instance of {dtypes.Dataset}. Got {type(dataset)}"
-            )
-
-        darfix_dataset = dataset.dataset
-
-        indices, bg_indices = darfix_dataset.partition_by_intensity(
-            bins=self.get_input_value("bins", None),
-            bottom_bin=self.get_input_value("filter_bottom_bin_idx", None),
-            top_bin=self.get_input_value("filter_top_bin_idx", None),
-        )
-        self.outputs.dataset = dtypes.Dataset(
-            dataset=darfix_dataset,
-            indices=indices,
-            bg_indices=bg_indices,
-            bg_dataset=dataset.bg_dataset,
-        )
+warnings.warn(
+    f"The '{__name__}' module is deprecated and will be removed in a future release. "
+    "Please replace module name `datapartition` by `data_partition`",
+    DeprecationWarning,
+    stacklevel=2,
+)

darfix/tasks/dimension_definition.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+from typing import Iterable
+
+import numpy
+from ewokscore import Task
+from ewokscore.missing_data import MISSING_DATA
+from ewokscore.missing_data import MissingData
+from ewokscore.model import BaseInputModel
+from pydantic import ConfigDict
+from pydantic import Field
+
+from darfix import dtypes
+from darfix.core.dataset import ImageDataset
+from darfix.core.dimension import AcquisitionDims
+from darfix.core.dimension import Dimension
+from darfix.core.dimension import find_dimensions_from_metadata
+from darfix.core.fscan_parser import fscan_get_dimensions
+from darfix.core.zigzag_mode import reorder_frames_of_zigzag_scan
+
+_logger = logging.getLogger(__file__)
+
+
+class Inputs(BaseInputModel):
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    dataset: dtypes.Dataset
+    """ Input dataset containing a stack of images """
+    dims: dict[int, Any] | MissingData = Field(
+        default=MISSING_DATA,
+        examples=[
+            {
+                0: {"name": "diffrx", "size": 5, "range": [0.0, 5.0, 1.0]},
+                1: {"name": "diffry", "size": 10, "range": [0.0, 10.0, 1.0]},
+            }
+        ],
+        description="Dimensions to use for the dataset. If not provided, the task will try to find dimensions from metadata.",
+    )
+    tolerance: float | MissingData = MISSING_DATA
+    """Tolerance to use for finding dimensions from metadata. Default is 1e-9."""
+    is_zigzag: bool | MissingData = MISSING_DATA
+    """Set to True if the scan was a zigzag scan (slow motor moving back and forth). Defaults to False."""
+
+
+class DimensionDefinition(
+    Task,
+    input_model=Inputs,
+    output_names=["dataset"],
+):
+    """
+    Fit dimension of given dataset.
+    If dims are provided then will use them. else will call 'find_dimensions' with the provided tolerance or the default one.
+    """
+
+    DEFAULT_TOLERANCE = 1e-9
+
+    def run(self):
+        if not isinstance(self.inputs.dataset, dtypes.Dataset):
+            raise TypeError(
+                f"'dataset' input should be an instance of {dtypes.Dataset}. Got {type(self.inputs.dataset)}"
+            )
+
+        dataset = self.inputs.dataset.dataset
+        if not isinstance(dataset, dtypes.ImageDataset):
+            raise TypeError(
+                f"self.inputs.dataset is expected to be an instance of {dtypes.ImageDataset}. Get {type(dataset)}"
+            )
+
+        fscan_parameters = fscan_get_dimensions(dataset)
+
+        dims = self._handle_dims(
+            fscan_parameters[1] if fscan_parameters else None,
+            dataset.metadata_dict,
+            user_input=self._get_dimensions_from_default_inputs(),
+        )
+        is_zigzag = self._handle_is_zigzag(
+            fscan_parameters[0] if fscan_parameters else None,
+            user_input=self.get_input_value("is_zigzag", None),
+        )
+
+        assert_dimensions_ok(dataset, dims.values())
+
+        if is_zigzag:
+            reorder_frames_of_zigzag_scan(dims, dataset)
+
+        # Reshape the dataset with the new dimensions
+
+        dataset.dims = dims
+        dataset.reshape_data()
+        self.outputs.dataset = dtypes.Dataset(
+            dataset=dataset,
+            bg_dataset=self.inputs.dataset.bg_dataset,
+        )
+
+    def _get_dimensions_from_default_inputs(self) -> AcquisitionDims | None:
+
+        raw_dims = self.get_input_value("dims", None)
+
+        if raw_dims is None:
+            return None
+
+        try:
+            return AcquisitionDims.from_dict(raw_dims)
+        except ValueError as e:
+            # TODO: Should we really silence the error here?
+            _logger.error(f"Encountered {e} when parsing default raw_dims: {raw_dims}")
+            return None
+
+    def _handle_is_zigzag(self, fscan_input: bool | None, user_input: bool | None):
+        if user_input is not None:
+            _logger.debug("is_zigzag set by user")
+            return user_input
+
+        if fscan_input is not None:
+            _logger.debug("is_zigzag set by fscan")
+            return fscan_input
+
+        _logger.debug("Using default value (False) for is_zigzag")
+        return False
+
+    def _handle_dims(
+        self,
+        fscan_dims: dict[int, Dimension] | None,
+        metadata_dict: dict,
+        user_input: AcquisitionDims | None,
+    ) -> AcquisitionDims:
+        if user_input is not None:
+            _logger.debug("dims set by user")
+            return user_input
+
+        if fscan_dims is not None:
+            _logger.debug("dims set by fscan")
+            return AcquisitionDims.from_dict(fscan_dims)
+
+        _logger.debug("dims computed from metadata")
+        return self._compute_dimensions_from_metadata(metadata_dict)
+
+    def _compute_dimensions_from_metadata(
+        self, metadata_dict: dict[str, numpy.ndarray]
+    ) -> AcquisitionDims:
+
+        tolerance = self.get_input_value("tolerance", self.DEFAULT_TOLERANCE)
+
+        return find_dimensions_from_metadata(
+            metadata_dict,
+            tolerance,
+        )
+
+
+def assert_dimensions_ok(dataset: ImageDataset, dims: Iterable[Dimension]) -> None:
+
+    error_msg = get_dimensions_error(dataset, dims)
+    if error_msg:
+        raise RuntimeError(error_msg)
+
+
+def get_dimensions_error(
+    dataset: ImageDataset, dims: Iterable[Dimension]
+) -> str | None:
+
+    shape = []
+
+    # Check name, min and max
+    for dimension in dims:
+
+        shape.append(dimension.size)
+
+        if dimension.name not in dataset.metadata_dict:
+            return f"Dimension with name '{dimension.name}' is not in the metadata."
+        metadata_min = numpy.min(dataset.metadata_dict[dimension.name])
+        metadata_max = numpy.max(dataset.metadata_dict[dimension.name])
+        tol = metadata_max - metadata_min
+        # Tolerance for out‑of‑range values.
+        # An erroneous value is considered invalid only if it exceeds the (min‑max) range by at least a factor of two.
+        # This tolerance prevents occasional false‑negative validation of scan‑parameter metadata.
+        metadata_min_with_tol = metadata_min - tol
+        metadata_max_with_tol = metadata_max + tol
+
+        if not (metadata_min_with_tol <= dimension.start <= metadata_max_with_tol):
+            return f"Dimension with name '{dimension.name}' start value = {dimension.start} but this is outside the dimension range [{metadata_min} → {metadata_max}]."
+
+        if not (metadata_min_with_tol <= dimension.stop <= metadata_max_with_tol):
+            return f"Dimension with name '{dimension.name}' stop value = {dimension.stop} but this is outside the dimension range [{metadata_min} → {metadata_max}]."
+
+    if len(shape) == 0:
+        return "None dimension are defined."
+
+    dims_size = numpy.prod(shape)
+
+    # Check size
+    if dims_size != dataset.nframes:
+        product_string = " x ".join([str(size) for size in shape])
+
+        return f"Dimensions do not match number of frames → {product_string} = {dims_size} ≠ {dataset.nframes}."
+
+    return None

darfix/tasks/dimensiondefinition.py

@@ -1,199 +1,10 @@
-from __future__ import annotations
+import warnings
 
-import logging
-from typing import Any
-from typing import Iterable
+from .dimension_definition import DimensionDefinition  # noqa: F401
 
-import numpy
-from ewokscore import Task
-from ewokscore.missing_data import MISSING_DATA
-from ewokscore.missing_data import MissingData
-from ewokscore.model import BaseInputModel
-from pydantic import ConfigDict
-from pydantic import Field
-
-from darfix import dtypes
-from darfix.core.dataset import ImageDataset
-from darfix.core.dimension import AcquisitionDims
-from darfix.core.dimension import Dimension
-from darfix.core.dimension import find_dimensions_from_metadata
-from darfix.core.fscan_parser import fscan_get_dimensions
-from darfix.core.zigzag_mode import reorder_frames_of_zigzag_scan
-
-_logger = logging.getLogger(__file__)
-
-
-class Inputs(BaseInputModel):
-    model_config = ConfigDict(use_attribute_docstrings=True)
-    dataset: dtypes.Dataset
-    """ Input dataset containing a stack of images """
-    dims: dict[int, Any] | MissingData = Field(
-        default=MISSING_DATA,
-        examples=[
-            {
-                0: {"name": "diffrx", "size": 5, "range": [0.0, 5.0, 1.0]},
-                1: {"name": "diffry", "size": 10, "range": [0.0, 10.0, 1.0]},
-            }
-        ],
-        description="Dimensions to use for the dataset. If not provided, the task will try to find dimensions from metadata.",
-    )
-    tolerance: float | MissingData = MISSING_DATA
-    """Tolerance to use for finding dimensions from metadata. Default is 1e-9."""
-    is_zigzag: bool | MissingData = MISSING_DATA
-    """Set to True if the scan was a zigzag scan (slow motor moving back and forth). Defaults to False."""
-
-
-class DimensionDefinition(
-    Task,
-    input_model=Inputs,
-    output_names=["dataset"],
-):
-    """
-    Fit dimension of given dataset.
-    If dims are provided then will use them. else will call 'find_dimensions' with the provided tolerance or the default one.
-    """
-
-    DEFAULT_TOLERANCE = 1e-9
-
-    def run(self):
-        if not isinstance(self.inputs.dataset, dtypes.Dataset):
-            raise TypeError(
-                f"'dataset' input should be an instance of {dtypes.Dataset}. Got {type(self.inputs.dataset)}"
-            )
-
-        dataset = self.inputs.dataset.dataset
-        if not isinstance(dataset, dtypes.ImageDataset):
-            raise TypeError(
-                f"self.inputs.dataset is expected to be an instance of {dtypes.ImageDataset}. Get {type(dataset)}"
-            )
-
-        fscan_parameters = fscan_get_dimensions(dataset)
-
-        dims = self._handle_dims(
-            fscan_parameters[1] if fscan_parameters else None,
-            dataset.metadata_dict,
-            user_input=self._get_dimensions_from_default_inputs(),
-        )
-        is_zigzag = self._handle_is_zigzag(
-            fscan_parameters[0] if fscan_parameters else None,
-            user_input=self.get_input_value("is_zigzag", None),
-        )
-
-        assert_dimensions_ok(dataset, dims.values())
-
-        if is_zigzag:
-            reorder_frames_of_zigzag_scan(dims, dataset)
-
-        # Reshape the dataset with the new dimensions
-
-        dataset.dims = dims
-        dataset.reshape_data()
-        self.outputs.dataset = dtypes.Dataset(
-            dataset=dataset,
-            indices=self.inputs.dataset.indices,
-            bg_indices=self.inputs.dataset.bg_indices,
-            bg_dataset=self.inputs.dataset.bg_dataset,
-        )
-
-    def _get_dimensions_from_default_inputs(self) -> AcquisitionDims | None:
-
-        raw_dims = self.get_input_value("dims", None)
-
-        if raw_dims is None:
-            return None
-
-        try:
-            return AcquisitionDims.from_dict(raw_dims)
-        except ValueError as e:
-            # TODO: Should we really silence the error here?
-            _logger.error(f"Encountered {e} when parsing default raw_dims: {raw_dims}")
-            return None
-
-    def _handle_is_zigzag(self, fscan_input: bool | None, user_input: bool | None):
-        if user_input:
-            _logger.debug("is_zigzag set by user")
-            return user_input
-
-        if fscan_input:
-            _logger.debug("is_zigzag set by fscan")
-            return fscan_input
-
-        _logger.debug("Using default value (False) for is_zigzag")
-        return False
-
-    def _handle_dims(
-        self,
-        fscan_dims: dict[int, Dimension] | None,
-        metadata_dict: dict,
-        user_input: AcquisitionDims | None,
-    ) -> AcquisitionDims:
-        if user_input is not None:
-            _logger.debug("dims set by user")
-            return user_input
-
-        if fscan_dims is not None:
-            _logger.debug("dims set by fscan")
-            return AcquisitionDims.from_dict(fscan_dims)
-
-        _logger.debug("dims computed from metadata")
-        return self._compute_dimensions_from_metadata(metadata_dict)
-
-    def _compute_dimensions_from_metadata(
-        self, metadata_dict: dict[str, numpy.ndarray]
-    ) -> AcquisitionDims:
-
-        tolerance = self.get_input_value("tolerance", self.DEFAULT_TOLERANCE)
-
-        return find_dimensions_from_metadata(
-            metadata_dict,
-            tolerance,
-        )
-
-
-def assert_dimensions_ok(dataset: ImageDataset, dims: Iterable[Dimension]) -> None:
-
-    error_msg = get_dimensions_error(dataset, dims)
-    if error_msg:
-        raise RuntimeError(error_msg)
-
-
-def get_dimensions_error(
-    dataset: ImageDataset, dims: Iterable[Dimension]
-) -> str | None:
-
-    shape = []
-
-    # Check name, min and max
-    for dimension in dims:
-
-        shape.append(dimension.size)
-
-        if dimension.name not in dataset.metadata_dict:
-            return f"Dimension with name '{dimension.name}' is not in the metadata."
-        metadata_min = numpy.min(dataset.metadata_dict[dimension.name])
-        metadata_max = numpy.max(dataset.metadata_dict[dimension.name])
-        tol = metadata_max - metadata_min
-        # Tolerance for out‑of‑range values.
-        # An erroneous value is considered invalid only if it exceeds the (min‑max) range by at least a factor of two.
-        # This tolerance prevents occasional false‑negative validation of scan‑parameter metadata.
-        metadata_min_with_tol = metadata_min - tol
-        metadata_max_with_tol = metadata_max + tol
-
-        if not (metadata_min_with_tol <= dimension.start <= metadata_max_with_tol):
-            return f"Dimension with name '{dimension.name}' start value = {dimension.start} but this is outside the dimension range [{metadata_min} → {metadata_max}]."
-
-        if not (metadata_min_with_tol <= dimension.stop <= metadata_max_with_tol):
-            return f"Dimension with name '{dimension.name}' stop value = {dimension.stop} but this is outside the dimension range [{metadata_min} → {metadata_max}]."
-
-    if len(shape) == 0:
-        return "None dimension are defined."
-
-    dims_size = numpy.prod(shape)
-
-    # Check size
-    if dims_size != dataset.nframes:
-        product_string = " x ".join([str(size) for size in shape])
-
-        return f"Dimensions do not match number of frames → {product_string} ≠ {dataset.nframes}."
-
-    return None
+warnings.warn(
+    f"The '{__name__}' module is deprecated and will be removed in a future release. "
+    "Please replace module name `dimensiondefinition` by `dimension_definition`",
+    DeprecationWarning,
+    stacklevel=2,
+)

darfix/tasks/grain_plot.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import Literal
+
+import numpy
+from ewokscore import Task
+from ewokscore.missing_data import MISSING_DATA
+from ewokscore.missing_data import MissingData
+from ewokscore.model import BaseInputModel
+from pydantic import ConfigDict
+from silx.io.dictdump import dicttonx
+from silx.math.combo import min_max
+
+from darfix import dtypes
+from darfix.core.moment_types import MomentType
+
+from ..core.grainplot import DimensionRange
+from ..core.grainplot import GrainPlotData
+from ..core.grainplot import GrainPlotMaps
+from ..core.grainplot import generate_grain_maps_nxdict
+
+_logger = logging.getLogger(__file__)
+
+
+class Inputs(BaseInputModel):
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    dataset: dtypes.Dataset
+    """ Input dataset containing a stack of images """
+    dimensions: tuple[int, int] = (0, 1)
+    """Dimension indices to use for the maps. Default is (0, 1), which means the two first dimensions."""
+    range: tuple[DimensionRange | None, DimensionRange | None] = (None, None)
+    """Dimensionrange for the two dimensions. If None, use the Center of Mass min and max for the both dimensions."""
+    save_maps: bool = True
+    """Whether to save the maps to file. Default is True."""
+    filename: str | MissingData = MISSING_DATA
+    """Only used if save_maps is True. Filename to save the maps to. Default is 'maps.h5' in the dataset directory."""
+    orientation_img_origin: Literal["dims", "center"] = "dims"
+    "Origin for the orientation distribution image. Can be 'dims', 'center' or None. Default is 'dims'."
+
+
+class GrainPlot(
+    Task,
+    input_model=Inputs,
+    output_names=["dataset"],
+):
+    """Generates and saves maps of Center of Mass, FWHM, Skewness, Kurtosis, Orientation distribution and Mosaicity."""
+
+    def run(self):
+
+        inputs = Inputs(**self.get_input_values())
+
+        default_filename = os.path.join(inputs.dataset.dataset._dir, "maps.h5")
+        filename: str = self.get_input_value("filename", default_filename)
+
+        moments = inputs.dataset.dataset.apply_moments()
+        grainPlotMaps = GrainPlotMaps.from_dataset(inputs.dataset)
+
+        # mosaicity and orientation can only be computed for 2D+ datasets
+        if grainPlotMaps.dims.ndim > 1 and inputs.save_maps:
+            dimension1, dimension2 = inputs.dimensions
+            dimension1_range, dimension2_range = inputs.range
+
+            if dimension1_range is None:
+                dimension1_range = _computeMinMax(moments[dimension1][MomentType.COM])
+            if dimension2_range is None:
+                dimension2_range = _computeMinMax(moments[dimension2][MomentType.COM])
+
+            orientation_dist_data = GrainPlotData(
+                grainPlotMaps,
+                x_dimension=dimension1,
+                y_dimension=dimension2,
+                x_dimension_range=dimension1_range,
+                y_dimension_range=dimension2_range,
+            )
+            assert orientation_dist_data is not None
+        else:
+            orientation_dist_data = None
+
+        # Save data if asked
+        if inputs.save_maps:
+            nxdict = generate_grain_maps_nxdict(grainPlotMaps, orientation_dist_data)
+            os.makedirs(Path(filename).parent, exist_ok=True)
+            dicttonx(nxdict, filename)
+
+        self.outputs.dataset = inputs.dataset
+
+
+def _computeMinMax(array: numpy.ndarray) -> DimensionRange:
+    min_max_result = min_max(array)
+    return min_max_result.minimum, min_max_result.maximum

darfix/tasks/grainplot.py

@@ -1,105 +1,10 @@
-from __future__ import annotations
+import warnings
 
-import logging
-import os
-from pathlib import Path
-from typing import Literal
+from .grain_plot import GrainPlot  # noqa: F401
 
-import numpy
-from ewokscore import Task
-from ewokscore.missing_data import MISSING_DATA
-from ewokscore.missing_data import MissingData
-from ewokscore.model import BaseInputModel
-from pydantic import ConfigDict
-from silx.io.dictdump import dicttonx
-from silx.math.combo import min_max
-
-from darfix import dtypes
-from darfix.core.moment_types import MomentType
-
-from ..core.grainplot import DimensionRange
-from ..core.grainplot import GrainPlotMaps
-from ..core.grainplot import OrientationDistData
-from ..core.grainplot import compute_mosaicity
-from ..core.grainplot import generate_grain_maps_nxdict
-
-_logger = logging.getLogger(__file__)
-
-
-class Inputs(BaseInputModel):
-    model_config = ConfigDict(use_attribute_docstrings=True)
-    dataset: dtypes.Dataset
-    """ Input dataset containing a stack of images """
-    dimensions: tuple[int, int] = (0, 1)
-    """Dimension indices to use for the maps. Default is (0, 1), which means the two first dimensions."""
-    range: tuple[DimensionRange | None, DimensionRange | None] = (None, None)
-    """Dimensionrange for the two dimensions. If None, use the Center of Mass min and max for the both dimensions."""
-    save_maps: bool = True
-    """Whether to save the maps to file. Default is True."""
-    filename: str | MissingData = MISSING_DATA
-    """Only used if save_maps is True. Filename to save the maps to. Default is 'maps.h5' in the dataset directory."""
-    orientation_img_origin: Literal["dims", "center"] = "dims"
-    "Origin for the orientation distribution image. Can be 'dims', 'center' or None. Default is 'dims'."
-
-
-class GrainPlot(
-    Task,
-    input_model=Inputs,
-    output_names=["dataset"],
-):
-    """Generates and saves maps of Center of Mass, FWHM, Skewness, Kurtosis, Orientation distribution and Mosaicity."""
-
-    def run(self):
-
-        inputs = Inputs(**self.get_input_values())
-
-        default_filename = os.path.join(inputs.dataset.dataset._dir, "maps.h5")
-        filename: str = self.get_input_value("filename", default_filename)
-
-        moments = inputs.dataset.dataset.apply_moments()
-        grainPlotMaps = GrainPlotMaps.from_dataset(inputs.dataset)
-
-        # mosaicity and orientation can only be computed for 2D+ datasets
-        if grainPlotMaps.dims.ndim > 1 and inputs.save_maps:
-            dimension1, dimension2 = inputs.dimensions
-            dimension1_range, dimension2_range = inputs.range
-
-            if dimension1_range is None:
-                dimension1_range = _computeMinMax(moments[dimension1][MomentType.COM])
-            if dimension2_range is None:
-                dimension2_range = _computeMinMax(moments[dimension2][MomentType.COM])
-
-            mosaicity = compute_mosaicity(
-                moments,
-                x_dimension=dimension1,
-                y_dimension=dimension2,
-                x_dimension_range=dimension1_range,
-                y_dimension_range=dimension2_range,
-            )
-
-            orientation_dist_data = OrientationDistData(
-                grainPlotMaps,
-                x_dimension=dimension1,
-                y_dimension=dimension2,
-                x_dimension_range=dimension1_range,
-                y_dimension_range=dimension2_range,
-            )
-            assert orientation_dist_data is not None
-        else:
-            orientation_dist_data = None
-            mosaicity = None
-
-        # Save data if asked
-        if inputs.save_maps:
-            nxdict = generate_grain_maps_nxdict(
-                grainPlotMaps, mosaicity, orientation_dist_data
-            )
-            os.makedirs(Path(filename).parent, exist_ok=True)
-            dicttonx(nxdict, filename)
-
-        self.outputs.dataset = inputs.dataset
-
-
-def _computeMinMax(array: numpy.ndarray) -> DimensionRange:
-    min_max_result = min_max(array)
-    return min_max_result.minimum, min_max_result.maximum
+warnings.warn(
+    f"The '{__name__}' module is deprecated and will be removed in a future release. "
+    "Please replace module name `grainplot` by `grain_plot`",
+    DeprecationWarning,
+    stacklevel=2,
+)