refact: replace sys.exit by raise

Author: adebardo

.pylintrc

@@ -103,7 +103,6 @@ max-nested-blocks=6
 # inconsistent-return-statements if a never returning function is called then
 # it will be considered as an explicit return statement and no message will be
 # printed.
-never-returning-functions=sys.exit
 
 
 [SPELLING]

pandora/check_configuration.py

@@ -28,7 +28,6 @@
 import copy
 import json
 import logging
-import sys
 from collections.abc import Mapping
 from os import PathLike
 from typing import Dict, Union, List, Tuple
@@ -83,15 +82,15 @@ def check_shape(dataset: xr.Dataset, ref: str, test: str) -> None:
 
     :param dataset: dataset
     :type dataset: xr.Dataset
-    :param ref: the reference image
-    :type str: name of image
+    :param ref: name of the reference image
+    :type ref: str
     :param test: the tested image
-    :type str: name of image
+    :type test: str
+    :return: None
     """
     # check only the rows and columns, the last two elements of the shape
     if dataset[ref].data.shape[-2:] != dataset[test].data.shape[-2:]:
-        logging.error("%s and %s must have the same shape", ref, test)
-        sys.exit(1)
+        raise ValueError(f" {ref} and {test} must have the same shape")
 
 
 def check_attributes(dataset: xr.Dataset, attribute_list: set) -> None:
@@ -100,13 +99,13 @@ def check_attributes(dataset: xr.Dataset, attribute_list: set) -> None:
 
     :param dataset: dataset
     :type dataset: xr.Dataset
-    :param attribute: the atribute to test
-    :type set: list of attribute names
+    :param attribute_list: the attribute to test
+    :type attribute_list: list
+    :return: None
     """
     attribute = attribute_list - set(dataset.attrs)
     if attribute:
-        logging.error("User must provide the % attribute(s)", attribute)
-        sys.exit(1)
+        raise AttributeError(f"User must provide the {attribute} attribute(s)")
 
 
 def check_dataset(dataset: xr.Dataset) -> None:
@@ -115,20 +114,19 @@ def check_dataset(dataset: xr.Dataset) -> None:
 
     :param dataset: dataset
     :type dataset: xr.Dataset
+    :return: None
     """
 
     # Check image
     if "im" not in dataset:
-        logging.error("User must provide an image im")
-        sys.exit(1)
+        raise AttributeError("User must provide an image im")
 
     # Check band in "band_im" coordinates
     check_band_names(dataset)
 
     # Check not empty image (all nan values)
     if np.isnan(dataset["im"].data).all():
-        logging.error("Image contains only nan values")
-        sys.exit(1)
+        raise ValueError("Image contains only nan values")
 
     # Check disparities
     if "disparity" in dataset:
@@ -147,26 +145,25 @@ def check_datasets(left: xr.Dataset, right: xr.Dataset) -> None:
     """
     Check that left and right datasets are correct
 
-    :param left: dataset
-    :type dataset: xr.Dataset
-    :param right: dataset
-    :type dataset: xr.Dataset
+    :param left: left dataset
+    :type left: xr.Dataset
+    :param right: right dataset
+    :type right: xr.Dataset
+    :return: None
     """
 
     # Check the dataset content
     check_dataset(left)
     check_dataset(right)
 
     # Check disparities at least on the left
-    if not "disparity" in left:
-        logging.error("left dataset must have disparity DataArray")
-        sys.exit(1)
+    if "disparity" not in left:
+        raise AttributeError("left dataset must have disparity DataArray")
 
     # Check shape
     # check only the rows and columns, the last two elements of the shape
     if left["im"].data.shape[-2:] != right["im"].data.shape[-2:]:
-        logging.error("left and right datasets must have the same shape")
-        sys.exit(1)
+        raise AttributeError("left and right datasets must have the same shape")
 
 
 def check_image_dimension(img1: rasterio.io.DatasetReader, img2: rasterio.io.DatasetReader) -> None:
@@ -180,8 +177,7 @@ def check_image_dimension(img1: rasterio.io.DatasetReader, img2: rasterio.io.Dat
     :return: None
     """
     if (img1.width != img2.width) or (img1.height != img2.height):
-        logging.error("Images must have the same size")
-        sys.exit(1)
+        raise AttributeError("Images must have the same size")
 
 
 def check_images(user_cfg: Dict[str, dict]) -> None:
@@ -218,8 +214,7 @@ def check_band_names(dataset: xr.Dataset) -> None:
     """
 
     if "band_im" in dataset.coords and not all(isinstance(band, str) for band in dataset.coords["band_im"].data):
-        logging.error("Band value must be str")
-        sys.exit(1)
+        raise TypeError("Band value must be str")
 
 
 def check_disparities_from_input(
@@ -229,18 +224,17 @@ def check_disparities_from_input(
     """
     Check disparities from user configuration
 
-    :param disparity: disparity to check if list it is a list of two values: min and max.
+    :param disparity: disparity to check if disparity is a list of two values: min and max.
     :type disparity:  list[int] | str | None
     :param img_left: path to the left image
     :type img_left: str
     :return: None
     """
     # disparities are integers
     if isinstance(disparity, list) and disparity[1] < disparity[0]:
-        logging.error("Disp_max must be bigger than Disp_min")
-        sys.exit(1)
+        raise ValueError("disp_max must be bigger than disp_min")
 
-    # disparites are grids
+    # disparities are grids
     if isinstance(disparity, str):
         # Load an image to compare the grid size
         img_left_ = rasterio_open(img_left)
@@ -249,17 +243,14 @@ def check_disparities_from_input(
 
         # check that disparity grids is a 2-channel grid
         if disparity_reader.count != 2:
-            logging.error("Disparity grids must be a 2-channel grid")
-            sys.exit(1)
+            raise AttributeError("Disparity grids must be a 2-channel grid")
 
         # check that disp_min has the same size as the image
         if (disparity_reader.width != img_left_.width) or (disparity_reader.height != img_left_.height):
-            logging.error("Disparity grids and image must have the same size")
-            sys.exit(1)
+            raise AttributeError("Disparity grids and image must have the same size")
 
         if (disparity_reader.read(1) > disparity_reader.read(2)).any():
-            logging.error("Disp_max must be bigger than Disp_min")
-            sys.exit(1)
+            raise ValueError("disp_max must be bigger than disp_min")
 
 
 def check_disparities_from_dataset(disparity: xr.DataArray) -> None:
@@ -274,15 +265,12 @@ def check_disparities_from_dataset(disparity: xr.DataArray) -> None:
     :return: None
     """
     if "band_disp" not in disparity.coords:
-        logging.error("Disparity xr.Dataset must have a band_disp coordinate")
-        sys.exit(1)
+        raise AttributeError("Disparity xr.Dataset must have a band_disp coordinate")
     band_disp = disparity.coords["band_disp"].data
     if not {"min", "max"}.issubset(band_disp):
-        logging.error("Disparity xr.Dataset must have a band_disp coordinate with min and max band")
-        sys.exit(1)
+        raise AttributeError("Disparity xr.Dataset must have a band_disp coordinate with min and max band")
     if (disparity.sel(band_disp="min").data > disparity.sel(band_disp="max").data).any():
-        logging.error("Disp_max grid must be bigger than Disp_min grid for each pixel")
-        sys.exit(1)
+        raise AttributeError("Disp_max grid must be bigger than Disp_min grid for each pixel")
 
 
 def get_config_input(user_cfg: Dict[str, dict]) -> Dict[str, dict]:
@@ -356,8 +344,7 @@ def memory_consumption_estimation(
         input_cfg = {"left": {"disp": disparity_interval, "img": img_path}, "right": {"img": img_path}}
         user_input = {"input": input_cfg}
     else:
-        logging.error("%s must be a Dict or a Tuple", user_input)
-        sys.exit(1)
+        raise TypeError(f"{user_input} must be a dict or a tuple")
 
     # Read input image
     img = rasterio_open(img_path)

pandora/img_tools.py

@@ -25,10 +25,8 @@
 
 from __future__ import annotations
 
-import logging
 import warnings
 from typing import List, Union, Tuple, cast, Dict
-import sys
 
 import numpy as np
 import rasterio
@@ -87,8 +85,7 @@ def get_window(roi: Dict, width: int, height: int) -> Window:
 
     # check roi outside
     if col_off > width or row_off > height or (col_off + roi_width) < 0 or (row_off + roi_height) < 0:
-        logging.error("Roi specified is outside the image")
-        sys.exit(1)
+        raise ValueError("Roi specified is outside the image")
 
     # overlap roi and image
     # right side
@@ -144,7 +141,7 @@ def add_disparity(
 
 def add_classif(dataset: xr.Dataset, classif: Union[str, None], window: Window) -> xr.Dataset:
     """
-    Add classification informations and image to datasaet
+    Add classification information and image to dataset
 
     :param dataset: xarray dataset without classification
     :type dataset: xr.Dataset
@@ -169,7 +166,7 @@ def add_classif(dataset: xr.Dataset, classif: Union[str, None], window: Window)
 
 def add_segm(dataset: xr.Dataset, segm: Union[str, None], window: Window) -> xr.Dataset:
     """
-    Add Segmentation informations and image to datasaet
+    Add Segmentation information and image to dataset
 
     :param dataset: xarray dataset without segmentation
     :type dataset: xr.Dataset
@@ -191,9 +188,9 @@ def add_segm(dataset: xr.Dataset, segm: Union[str, None], window: Window) -> xr.
 
 def add_no_data(dataset: xr.Dataset, no_data: Union[int, float], no_data_pixels: np.ndarray) -> xr.Dataset:
     """
-    Add no data informations to datasaet
+    Add no data information to dataset
 
-    :param dataset: xarray dataset without no_data informations
+    :param dataset: xarray dataset without no_data information
     :type dataset: xr.Dataset
     :param no_data: value
     :type no_data: int or float
@@ -216,7 +213,7 @@ def add_mask(
     dataset: xr.Dataset, mask: Union[str, None], no_data_pixels: np.ndarray, width: int, height: int, window: Window
 ) -> xr.Dataset:
     """
-    Add mask informations and image to datasaet
+    Add mask information and image to dataset
 
     :param dataset: xarray dataset without mask
     :type dataset: xr.Dataset
@@ -228,6 +225,8 @@ def add_mask(
     :type width: int
     :param height: nb rows
     :type height: int
+    :param window: information about window
+    :type window: rasterio.window
     :return: dataset : updated dataset
     :rtype: xr.Dataset
     """
@@ -273,7 +272,7 @@ def create_dataset_from_inputs(input_config: dict, roi: dict = None) -> xr.Datas
 
     :param input_config: configuration used to create dataset.
     :type input_config: dict
-    :param roi: dictionnary with a roi
+    :param roi: dictionary with a roi
 
             "col": {"first": <value - int>, "last": <value - int>},
             "row": {"first": <value - int>, "last": <value - int>},
@@ -497,9 +496,9 @@ def interpolate_nodata_sgm(img: np.ndarray, valid: np.ndarray) -> Tuple[np.ndarr
     IEEE Transactions on pattern analysis and machine intelligence, 2007, vol. 30, no 2, p. 328-341.
 
     :param img: input image
-    :type img: 2D np.array (row, col)
+    :type img: 2D np.ndarray (row, col)
     :param valid: validity mask
-    :type valid: 2D np.array (row, col)
+    :type valid: 2D np.ndarray (row, col)
     :return: the interpolate input image, with the validity mask update :
 
         - If out & PANDORA_MSK_PIXEL_FILLED_NODATA != 0 : Invalid pixel : filled nodata pixel
@@ -540,11 +539,10 @@ def masks_pyramid(msk: np.ndarray, scale_factor: int, num_scales: int) -> List[n
     :return: a List that contains the different scaled masks
     :rtype: List of np.ndarray
     """
-    msk_pyramid = []
+    msk_pyramid = [msk]
     # Add the full resolution mask
-    msk_pyramid.append(msk)
     tmp_msk = msk
-    for scale in range(num_scales - 1):  # pylint: disable=unused-variable
+    for _ in range(num_scales - 1):
         # Decimate in the two axis
         tmp_msk = tmp_msk[::scale_factor, ::scale_factor]
         msk_pyramid.append(tmp_msk)
@@ -657,7 +655,7 @@ def check_inside_image(img: xr.Dataset, row: int, col: int) -> bool:
     :type row: int
     :param col: column coordinates
     :type col: int
-    :return: a boolean
+    :return: True if the coordinates row,col are inside the image
     :rtype: boolean
     """
     ny_, nx_ = img.dims["row"], img.dims["col"]
@@ -691,7 +689,7 @@ def census_transform(image: xr.Dataset, window_size: int, band: str = None) -> x
 
     # Create a sliding window of using as_strided function : this function create a new a view (by manipulating data
     #  pointer) of the image array with a different shape. The new view pointing to the same memory block as
-    # image so it does not consume any additional memory.
+    # image, so it does not consume any additional memory.
     str_row, str_col = selected_band.strides
     shape_windows = (
         ny_ - (window_size - 1),
@@ -780,22 +778,22 @@ def find_valid_neighbors(dirs: np.ndarray, disp: np.ndarray, valid: np.ndarray,
     Find valid neighbors along directions
 
     :param dirs: directions
-    :type dirs: 2D np.array (row, col)
+    :type dirs: 2D np.ndarray (row, col)
     :param disp: disparity map
-    :type disp: 2D np.array (row, col)
+    :type disp: 2D np.ndarray (row, col)
     :param valid: validity mask
-    :type valid: 2D np.array (row, col)
+    :type valid: 2D np.ndarray (row, col)
     :param row: row current value
     :type row: int
     :param col: col current value
     :type col: int
     :return: valid neighbors
-    :rtype: 2D np.array
+    :rtype: 2D np.ndarray
     """
     ncol, nrow = disp.shape
     # Maximum path length
     max_path_length = max(nrow, ncol)
-    # For each directions
+    # For each direction
     valid_neighbors = np.zeros(8, dtype=np.float32)
     for direction in range(8):
         # Find the first valid pixel in the current path
@@ -843,8 +841,7 @@ def compute_mean_patch(img: xr.Dataset, row: int, col: int, win_size: int) -> np
             dtype=np.float32,
         )
 
-    logging.error("The window is outside the image")
-    raise IndexError
+    raise IndexError("The window is outside the image")
 
 
 def compute_std_raster(img: xr.Dataset, win_size: int, band: str = None) -> np.ndarray:
@@ -903,7 +900,7 @@ def read_disp(disparity: tuple[int, int] | list[int] | str) -> tuple[int, int] |
 
     if not isinstance(disparity, str):
         # cast because of mypy when we give list as input while it expects a tuple as output
-        # not sure it is the best solution
+        # not sure if it is the best solution
         return cast(Tuple[int, int], tuple(disparity))
 
     raster_disparity = rasterio_open(disparity)