[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

examples/code_snippets/plotting/plot_rgb_single_cell_image_grid.py

@@ -6,11 +6,11 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
-
-from scportrait.data._single_cell_images import dataset2_h5sc
 from scportrait.pl.h5sc import _plot_image_grid
 from scportrait.pl.vis import colorize
 
+from scportrait.data._single_cell_images import dataset2_h5sc
+
 # get dataset
 h5sc = dataset2_h5sc()
 

examples/code_snippets/plotting/plot_rgb_single_cell_images.py

@@ -4,9 +4,9 @@
 """
 
 import matplotlib.pyplot as plt
+from scportrait.pl.vis import generate_composite
 
 from scportrait.data._single_cell_images import dataset2_h5sc
-from scportrait.pl.vis import generate_composite
 
 # select images you want to plot and colorize
 h5sc = dataset2_h5sc()

src/scportrait/pipeline/_utils/sdata_io.py

@@ -445,9 +445,9 @@ def _load_seg_to_memmap(
         """
         _sdata = self._check_sdata_status(return_sdata=True)
 
-        assert all(
-            seg in _sdata.labels for seg in seg_name
-        ), "Not all passed segmentation elements found in sdata object."
+        assert all(seg in _sdata.labels for seg in seg_name), (
+            "Not all passed segmentation elements found in sdata object."
+        )
 
         seg_objects = [_sdata.labels[seg] for seg in seg_name]
 

src/scportrait/pipeline/extraction.py

@@ -116,9 +116,9 @@ def _check_config(self):
 
             if normalization_range is not None:
                 assert len(normalization_range) == 2, "Normalization range must be a tuple or list of length 2."
-                assert all(
-                    isinstance(x, float | int) and (0 <= x <= 1) for x in normalization_range
-                ), "Normalization range must be defined as a float between 0 and 1."
+                assert all(isinstance(x, float | int) and (0 <= x <= 1) for x in normalization_range), (
+                    "Normalization range must be defined as a float between 0 and 1."
+                )
 
                 # conver to tuple to ensure consistency
                 if isinstance(normalization_range, list):
@@ -388,9 +388,9 @@ def _get_centers(self) -> None:
         self.centers_cell_ids = _sdata[centers_name].index.values.compute()
 
         # ensure that the centers ids are unique
-        assert len(self.centers_cell_ids) == len(
-            set(self.centers_cell_ids)
-        ), "Cell ids in centers are not unique. Cannot proceed with extraction."
+        assert len(self.centers_cell_ids) == len(set(self.centers_cell_ids)), (
+            "Cell ids in centers are not unique. Cannot proceed with extraction."
+        )
 
         # double check that the cell_ids contained in the seg masks match to those from centers
         # THIS NEEDS TO BE IMPLEMENTED HERE

src/scportrait/pipeline/featurization.py

@@ -128,9 +128,9 @@ def _setup_channel_selection(self) -> None:
         if "channel_selection" in self.config.keys():
             channel_selection = self.config["channel_selection"]
             if isinstance(channel_selection, list):
-                assert all(
-                    isinstance(x, int) for x in channel_selection
-                ), "channel_selection should be a list of integers"
+                assert all(isinstance(x, int) for x in channel_selection), (
+                    "channel_selection should be a list of integers"
+                )
                 self.channel_selection = channel_selection
 
             elif isinstance(channel_selection, int):
@@ -212,21 +212,21 @@ def _get_single_cell_datafile_specs(self) -> None:
 
             # check to ensure that metadata that must be consistent between datasets is
             assert (x == n_masks[0] for x in n_masks), "number of masks are not consistent over all passed inputfiles."
-            assert (
-                x == n_channels[0] for x in n_channels
-            ), "number of channels are not consistent over all passed input files."
-            assert (
-                x == n_image_channels[0] for x in n_image_channels
-            ), "number of image channels are not consistent over all passed input files."
-            assert (
-                x == channel_mapping[0] for x in channel_mapping
-            ), "channel mapping is not consistent over all passed input files."
-            assert (
-                x == channel_names[0] for x in channel_names
-            ), "channel names are not consistent over all passed input files."
-            assert (
-                x == segmentation_channel[0] for x in segmentation_channel
-            ), "segmentation channel is not consistent over all passed input files."
+            assert (x == n_channels[0] for x in n_channels), (
+                "number of channels are not consistent over all passed input files."
+            )
+            assert (x == n_image_channels[0] for x in n_image_channels), (
+                "number of image channels are not consistent over all passed input files."
+            )
+            assert (x == channel_mapping[0] for x in channel_mapping), (
+                "channel mapping is not consistent over all passed input files."
+            )
+            assert (x == channel_names[0] for x in channel_names), (
+                "channel names are not consistent over all passed input files."
+            )
+            assert (x == segmentation_channel[0] for x in segmentation_channel), (
+                "segmentation channel is not consistent over all passed input files."
+            )
 
             # set variable names after assertions have passed to the first instance of each value
             self.n_masks = n_masks[0]
@@ -567,25 +567,25 @@ def generate_dataloader(
         # generate dataset
         self.log(f"Reading data from path: {dataset_paths}")
 
-        assert isinstance(
-            self.transforms, transforms.Compose
-        ), f"Transforms should be a torchvision.transforms.Compose object but recieved {self.transforms.__class__} instead."
+        assert isinstance(self.transforms, transforms.Compose), (
+            f"Transforms should be a torchvision.transforms.Compose object but recieved {self.transforms.__class__} instead."
+        )
         t = self.transforms
 
         if self.expected_imagesize is not None:
             self.log(f"Expected image size is set to {self.expected_imagesize}. Resizing images to this size.")
             t = transforms.Compose([t, transforms.Resize(self.expected_imagesize)])
 
         if isinstance(dataset_paths, list):
-            assert isinstance(
-                dataset_labels, list
-            ), "If multiple directories are provided, multiple labels must be provided."
+            assert isinstance(dataset_labels, list), (
+                "If multiple directories are provided, multiple labels must be provided."
+            )
             paths = dataset_paths
             dataset_labels = dataset_labels
         elif isinstance(dataset_paths, str):
-            assert isinstance(
-                dataset_labels, int
-            ), "If only one directory is provided, only one label must be provided."
+            assert isinstance(dataset_labels, int), (
+                "If only one directory is provided, only one label must be provided."
+            )
             paths = [dataset_paths]
             dataset_labels = [dataset_labels]
 
@@ -923,9 +923,9 @@ def __init__(self, *args, **kwargs):
             self._clean_log_file()
 
         # checks for additional essential parameters in the config file
-        assert (
-            self.label is not None
-        ), "'label' must be specified in the config file. This is the label used to save the results."
+        assert self.label is not None, (
+            "'label' must be specified in the config file. This is the label used to save the results."
+        )
 
     def _get_network_dir(self) -> pl.LightningModule:
         if self.network_dir in self.PRETRAINED_MODEL_NAMES:
@@ -1107,7 +1107,7 @@ def process(
                 path = os.path.join(self.run_path, f"{output_name}.csv")
 
                 # self._write_results_csv(results, path)
-                self._write_results_sdata(results, label=f"{self.__class__.__name__ }_{self.label}_{model.__name__}")
+                self._write_results_sdata(results, label=f"{self.__class__.__name__}_{self.label}_{model.__name__}")
             else:
                 all_results.append(results)
 
@@ -1143,9 +1143,9 @@ def __init__(self, *args, **kwargs):
             self._clean_log_file()
 
         # checks for additional essential parameters in the config file
-        assert (
-            self.label is not None
-        ), "'label' musst be specified in the config file. This is the label used to save the results."
+        assert self.label is not None, (
+            "'label' musst be specified in the config file. This is the label used to save the results."
+        )
 
     def _setup_transforms(self):
         if self.transforms is not None:
@@ -1273,7 +1273,7 @@ class based on the previous single-cell extraction. Therefore, no parameters nee
                 os.path.join(self.run_path, f"{output_name}.csv")
 
                 # self._write_results_csv(results, path)
-                self._write_results_sdata(results, label=f"{self.__class__.__name__ }_{model_name}")
+                self._write_results_sdata(results, label=f"{self.__class__.__name__}_{model_name}")
             else:
                 all_results[model_name] = results
 

src/scportrait/pipeline/project.py

@@ -720,15 +720,15 @@ def plot_input_image(
 
         if channels is not None:
             if isinstance(channels[0], int):
-                assert all(
-                    x in range(c) for x in channels
-                ), "The specified channel indices are not found in the spatialdata object."
+                assert all(x in range(c) for x in channels), (
+                    "The specified channel indices are not found in the spatialdata object."
+                )
                 valid_channels = [i for i in channels if isinstance(i, int)]
                 channel_names = [channel_names[i] for i in valid_channels]
             if isinstance(channels[0], str):
-                assert all(
-                    x in channel_names for x in channels
-                ), "The specified channel names are not found in the spatialdata object."
+                assert all(x in channel_names for x in channels), (
+                    "The specified channel names are not found in the spatialdata object."
+                )
                 channel_names = channels
 
             c = len(channels)
@@ -1358,9 +1358,9 @@ def load_input_from_dask(self, dask_array, channel_names: list[str], overwrite:
 
         self._cleanup_sdata_object()
 
-        assert (
-            len(channel_names) == dask_array.shape[0]
-        ), "Number of channel names does not match number of input images."
+        assert len(channel_names) == dask_array.shape[0], (
+            "Number of channel names does not match number of input images."
+        )
 
         self.channel_names = channel_names
 
@@ -1646,9 +1646,9 @@ def featurize(
 
         # check that prerequisits are fullfilled to featurize cells
         assert self.featurization_f is not None, "No featurization method defined."
-        assert (
-            self.nuc_seg_status or self.cyto_seg_status
-        ), "No nucleus or cytosol segmentation loaded. Please load a segmentation first."
+        assert self.nuc_seg_status or self.cyto_seg_status, (
+            "No nucleus or cytosol segmentation loaded. Please load a segmentation first."
+        )
         assert self.extraction_status, "No single cell data extracted. Please extract single cell data first."
 
         extraction_dir = self.extraction_f.get_directory()

src/scportrait/pipeline/segmentation/segmentation.py

@@ -1145,9 +1145,9 @@ def complete_segmentation(self, input_image, force_run=False):
         sharding_plan = self._get_sharding_plan(overwrite=False, force_read=True)
 
         # check to make sure that calculated sharding plan matches to existing sharding results
-        assert (
-            len(sharding_plan) == len(tile_directories)
-        ), "Calculated a different number of shards than found shard directories. This indicates a mismatch between the current loaded config file and the config file used to generate the exisiting partial segmentation. Please rerun the complete segmentation to ensure accurate results."
+        assert len(sharding_plan) == len(tile_directories), (
+            "Calculated a different number of shards than found shard directories. This indicates a mismatch between the current loaded config file and the config file used to generate the exisiting partial segmentation. Please rerun the complete segmentation to ensure accurate results."
+        )
 
         # select only those shards that did not complete successfully for further processing
         sharding_plan_complete = sharding_plan

src/scportrait/pipeline/segmentation/workflows/_base_segmentation_workflow.py

@@ -36,25 +36,25 @@ def _setup_maximum_intensity_projection(self):
         # check if channels that should be maximum intensity projected and combined are defined in the config
         if "combine_cytosol_channels" in self.config.keys():
             self.combine_cytosol_channels = self.config["combine_cytosol_channels"]
-            assert isinstance(
-                self.combine_cytosol_channels, list
-            ), "combine_cytosol_channels must be a list of integers specifying the indexes of the channels to combine."
-            assert (
-                len(self.combine_cytosol_channels) > 1
-            ), "combine_cytosol_channels must contain at least two integers specifying the indexes of the channels to combine."
+            assert isinstance(self.combine_cytosol_channels, list), (
+                "combine_cytosol_channels must be a list of integers specifying the indexes of the channels to combine."
+            )
+            assert len(self.combine_cytosol_channels) > 1, (
+                "combine_cytosol_channels must contain at least two integers specifying the indexes of the channels to combine."
+            )
             self.maximum_project_cytosol = True
         else:
             self.combine_cytosol_channels = None
             self.maximum_project_cytosol = False
 
         if "combine_nucleus_channels" in self.config.keys():
             self.combine_nucleus_channels = self.config["combine_nucleus_channels"]
-            assert isinstance(
-                self.combine_nucleus_channels, list
-            ), "combine_nucleus_channels must be a list of integers specifying the indexes of the channels to combine."
-            assert (
-                len(self.combine_nucleus_channels) > 1
-            ), "combine_nucleus_channels must contain at least two integers specifying the indexes of the channels to combine."
+            assert isinstance(self.combine_nucleus_channels, list), (
+                "combine_nucleus_channels must be a list of integers specifying the indexes of the channels to combine."
+            )
+            assert len(self.combine_nucleus_channels) > 1, (
+                "combine_nucleus_channels must contain at least two integers specifying the indexes of the channels to combine."
+            )
             self.maximum_project_nucleus = True
         else:
             self.combine_nucleus_channels = None
@@ -88,14 +88,14 @@ def _define_channels_to_extract_for_segmentation(self):
 
         # check validity of resulting list of segmentation channels
         assert len(self.segmentation_channels) > 0, "No segmentation channels specified in config file."
-        assert (
-            len(self.segmentation_channels) >= self.N_INPUT_CHANNELS
-        ), f"Fewer segmentation channels {self.segmentation_channels} provided than expected by segmentation method {self.N_INPUT_CHANNELS}."
+        assert len(self.segmentation_channels) >= self.N_INPUT_CHANNELS, (
+            f"Fewer segmentation channels {self.segmentation_channels} provided than expected by segmentation method {self.N_INPUT_CHANNELS}."
+        )
 
         if len(self.segmentation_channels) > self.N_INPUT_CHANNELS:
-            assert (
-                self.maximum_project_nucleus or self.maximum_project_cytosol
-            ), "More input channels provided than accepted by the segmentation method and no maximum intensity projection performed on any of the input values."
+            assert self.maximum_project_nucleus or self.maximum_project_cytosol, (
+                "More input channels provided than accepted by the segmentation method and no maximum intensity projection performed on any of the input values."
+            )
 
     def _remap_maximum_intensity_projection_channels(self):
         """After selecting channels that are passed to the segmentation update indexes of the channels for maximum intensity projection so that they reflect the provided image subset"""
@@ -153,9 +153,9 @@ def _transform_input_image(self, input_image):
 
         input_image = np.vstack(values)
 
-        assert (
-            input_image.shape[0] == self.N_INPUT_CHANNELS
-        ), f"Number of channels in input image {input_image.shape[0]} does not match the number of channels expected by segmentation method {self.N_INPUT_CHANNELS}."
+        assert input_image.shape[0] == self.N_INPUT_CHANNELS, (
+            f"Number of channels in input image {input_image.shape[0]} does not match the number of channels expected by segmentation method {self.N_INPUT_CHANNELS}."
+        )
 
         stop_transform = timeit.default_timer()
         self.transform_time = stop_transform - start_transform
@@ -474,9 +474,9 @@ def _check_for_size_filtering(self, mask_types: list[str]) -> None:
         If size filtering is turned on, the thresholds for filtering are loaded from the config file.
         """
 
-        assert all(
-            mask_type in self.MASK_NAMES for mask_type in mask_types
-        ), f"mask_types must be a list of strings that are valid mask names {self.MASK_NAMES}."
+        assert all(mask_type in self.MASK_NAMES for mask_type in mask_types), (
+            f"mask_types must be a list of strings that are valid mask names {self.MASK_NAMES}."
+        )
 
         if "filter_masks_size" in self.config.keys():
             self.filter_size = self.config["filter_masks_size"]
@@ -648,9 +648,9 @@ def _check_for_mask_matching_filtering(self) -> None:
         # sanity check provided values
         assert isinstance(self.filter_match_masks, bool), "`match_masks` must be a boolean value."
         if self.filter_match_masks:
-            assert isinstance(
-                self.mask_matching_filtering_threshold, float
-            ), "`filtering_threshold_mask_matching` for mask matching must be a float."
+            assert isinstance(self.mask_matching_filtering_threshold, float), (
+                "`filtering_threshold_mask_matching` for mask matching must be a float."
+            )
 
     def _perform_mask_matching_filtering(
         self,

src/scportrait/pipeline/selection.py

@@ -89,9 +89,9 @@ def _setup_selection(self):
         self.savepath = os.path.join(self.directory, savename)
 
         # check that the segmentation label exists
-        assert (
-            self.segmentation_channel_to_select in self.project.filehandler.get_sdata()._shared_keys
-        ), f"Segmentation channel {self.segmentation_channel_to_select} not found in sdata."
+        assert self.segmentation_channel_to_select in self.project.filehandler.get_sdata()._shared_keys, (
+            f"Segmentation channel {self.segmentation_channel_to_select} not found in sdata."
+        )
 
     def __get_coords(
         self, cell_ids: list, centers: list[tuple[int, int]], width: int = 60

src/scportrait/plotting/h5sc.py

@@ -298,9 +298,9 @@ def cell_grid_multi_channel(
         _cell_ids = adata.obs[DEFAULT_CELL_ID_NAME].sample(n_cells).values
 
     if row_labels is not None:
-        assert (
-            show_cell_id is False
-        ), "If manually providing row_labels, can not automatically annotate rows with cell IDs. Set `show_cell_id` to False."
+        assert show_cell_id is False, (
+            "If manually providing row_labels, can not automatically annotate rows with cell IDs. Set `show_cell_id` to False."
+        )
         assert len(row_labels) == n_cells, "Length of `row_labels` must match the number of cells to be visualized."
     else:
         row_labels = [f"cell ID {_id}" for _id in _cell_ids] if show_cell_id else None