konfai 1.2.5__tar.gz → 1.2.7__tar.gz

{konfai-1.2.5 → konfai-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konfai
-Version: 1.2.5
+Version: 1.2.7
 Summary: Modular and configurable Deep Learning framework with YAML and PyTorch
 Author-email: Valentin Boussot <boussot.v@gmail.com>
 License-Expression: Apache-2.0
@@ -21,6 +21,7 @@ Requires-Dist: SimpleITK
 Requires-Dist: lxml
 Requires-Dist: h5py
 Requires-Dist: pynvml
+Requires-Dist: requests
 Provides-Extra: vtk
 Requires-Dist: vtk; extra == "vtk"
 Provides-Extra: lpips

{konfai-1.2.5 → konfai-1.2.7}/konfai/data/augmentation.py

@@ -218,7 +218,7 @@ class DataAugmentation(NeedDevice, ABC):
     @abstractmethod
     def _inverse(self, index: int, a: int, tensor: torch.Tensor) -> torch.Tensor:
         pass
-
+    
 
 class EulerTransform(DataAugmentation):
 

{konfai-1.2.5 → konfai-1.2.7}/konfai/data/data_manager.py

@@ -515,7 +515,7 @@ class Data(ABC):
                 self.groups_src[group_src][group_dest].load(
                     group_src,
                     group_dest,
-                    [self.datasets[filename] for filename, _ in datasets[group_src]],
+                    list(self.datasets.values()),
                 )
                 model_have_input |= self.groups_src[group_src][group_dest].is_input
         if self.patch is not None:

{konfai-1.2.5 → konfai-1.2.7}/konfai/data/patching.py

@@ -219,7 +219,7 @@ class Patch(ABC):
         )
         slices = [s] + list(self._patch_slices[a][index][1:])
         data_sliced = data[slices_pre + slices]
-        if data_sliced.shape[len(slices_pre)] < bottom + top + 1:
+        if extend_slice > 0 and data_sliced.shape[len(slices_pre)] < bottom + top + 1:
             pad_bottom = 0
             pad_top = 0
             if self._patch_slices[a][index][0].start - bottom < 0:
@@ -335,7 +335,7 @@ class DatasetManager:
         self.data: list[torch.Tensor] = []
 
         for transform_function in transforms:
-            _shape = transform_function.transform_shape(_shape, cache_attribute)
+            _shape = transform_function.transform_shape(self.name, _shape, cache_attribute)
 
         self.patch = (
             DatasetPatch(

{konfai-1.2.5 → konfai-1.2.7}/konfai/data/transform.py

@@ -21,13 +21,19 @@ class Transform(NeedDevice, ABC):
     def set_datasets(self, datasets: list[Dataset]):
         self.datasets = datasets
 
-    def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
+    def transform_shape(self, name: str, shape: list[int], cache_attribute: Attribute) -> list[int]:
         return shape
 
     @abstractmethod
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         pass
 
+class TransformInverse(Transform, ABC):
+
+    def __init__(self, inverse: bool) -> None:
+        super().__init__()
+        self.apply_inverse = inverse
+        
     @abstractmethod
     def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         pass
@@ -52,8 +58,9 @@ class Clip(Transform):
         max_value: float | str = 1024,
         save_clip_min: bool = False,
         save_clip_max: bool = False,
-        mask: str | None = None
+        mask: str | None = None,
     ) -> None:
+        super().__init__()
         if isinstance(min_value, float) and isinstance(max_value, float) and max_value <= min_value:
             raise ValueError(
                 f"[Clip] Invalid clipping range: max_value ({max_value}) must be greater than min_value ({min_value})"
@@ -72,7 +79,10 @@ class Clip(Transform):
                     mask, _ = dataset.read_data(self.mask, name)
                     break
         if mask is None and self.mask is not None:
-            raise ValueError(f"Requested mask '{self.mask}' is not present in any dataset. Check your dataset group names or configuration.")
+            raise ValueError(
+                f"Requested mask '{self.mask}' is not present in any dataset. "
+                "Check your dataset group names or configuration."
+            )
         if mask is None:
             tensor_masked = tensor
         else:
@@ -88,7 +98,10 @@ class Clip(Transform):
                 except (IndexError, ValueError):
                     raise ValueError(f"Invalid format for min_value: '{self.min_value}'. Expected 'percentile:<float>'")
             else:
-                raise TypeError(f"Unsupported string for min_value: '{self.min_value}'. Must be a float, 'min', or 'percentile:<float>'.")
+                raise TypeError(
+                    f"Unsupported string for min_value: '{self.min_value}'."
+                    "Must be a float, 'min', or 'percentile:<float>'."
+                )
         else:
             min_value = self.min_value
 
@@ -102,10 +115,13 @@ class Clip(Transform):
                 except (IndexError, ValueError):
                     raise ValueError(f"Invalid format for max_value: '{self.max_value}'. Expected 'percentile:<float>'")
             else:
-                raise TypeError(f"Unsupported string for max_value: '{self.max_value}'. Must be a float, 'max', or 'percentile:<float>'.")
+                raise TypeError(
+                    f"Unsupported string for max_value: '{self.max_value}'."
+                    " Must be a float, 'max', or 'percentile:<float>'."
+                )
         else:
             max_value = self.max_value
-        
+
         tensor[torch.where(tensor < min_value)] = min_value
         tensor[torch.where(tensor > max_value)] = max_value
         if self.save_clip_min:
@@ -114,11 +130,8 @@ class Clip(Transform):
             cache_attribute["Max"] = max_value
         return tensor
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
-class Normalize(Transform):
+class Normalize(TransformInverse):
 
     def __init__(
         self,
@@ -126,7 +139,9 @@ class Normalize(Transform):
         channels: list[int] | None = None,
         min_value: float = -1,
         max_value: float = 1,
+        inverse: bool = True
     ) -> None:
+        super().__init__(inverse)
         if max_value <= min_value:
             raise ValueError(
                 f"[Normalize] Invalid range: max_value ({max_value}) must be greater than min_value ({min_value})"
@@ -179,15 +194,17 @@ class Normalize(Transform):
             return (tensor - self.min_value) * (input_max - input_min) / (self.max_value - self.min_value) + input_min
 
 
-class Standardize(Transform):
+class Standardize(TransformInverse):
 
     def __init__(
         self,
         lazy: bool = False,
         mean: list[float] | None = None,
         std: list[float] | None = None,
-        mask: str | None = None
+        mask: str | None = None,
+        inverse: bool = True
     ) -> None:
+        super().__init__(inverse)
         self.lazy = lazy
         self.mean = mean
         self.std = std
@@ -201,19 +218,25 @@ class Standardize(Transform):
                     mask, _ = dataset.read_data(self.mask, name)
                     break
         if mask is None and self.mask is not None:
-            raise ValueError(f"Requested mask '{self.mask}' is not present in any dataset. Check your dataset group names or configuration.")
+            raise ValueError(
+                f"Requested mask '{self.mask}' is not present in any dataset."
+                " Check your dataset group names or configuration."
+            )
         if mask is None:
             tensor_masked = tensor
         else:
             tensor_masked = tensor[mask == 1]
 
         if "Mean" not in cache_attribute:
-            cache_attribute["Mean"] = torch.tensor([torch.mean(tensor_masked.type(torch.float32))]) if self.mean is None else torch.tensor([self.mean])
-            
+            cache_attribute["Mean"] = (
+                torch.tensor([torch.mean(tensor_masked.type(torch.float32))])
+                if self.mean is None
+                else torch.tensor([self.mean])
+            )
+
         if "Std" not in cache_attribute:
             cache_attribute["Std"] = (
-                torch.tensor([torch.std(
-                    tensor_masked.type(torch.float32))])
+                torch.tensor([torch.std(tensor_masked.type(torch.float32))])
                 if self.std is None
                 else torch.tensor([self.std])
             )
@@ -233,9 +256,10 @@ class Standardize(Transform):
             return tensor * std + mean
 
 
-class TensorCast(Transform):
+class TensorCast(TransformInverse):
 
-    def __init__(self, dtype: str = "float32") -> None:
+    def __init__(self, dtype: str = "float32", inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.dtype: torch.dtype = getattr(torch, dtype)
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -253,9 +277,10 @@ class TensorCast(Transform):
         return tensor.to(TensorCast.safe_dtype_cast(cache_attribute.pop("dtype")))
 
 
-class Padding(Transform):
+class Padding(TransformInverse):
 
-    def __init__(self, padding: list[int] = [0, 0, 0, 0, 0, 0], mode: str = "constant") -> None:
+    def __init__(self, padding: list[int] = [0, 0, 0, 0, 0, 0], mode: str = "constant", inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.padding = padding
         self.mode = mode
 
@@ -275,7 +300,7 @@ class Padding(Transform):
         ).squeeze(0)
         return result
 
-    def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
+    def transform_shape(self, name: str, shape: list[int], cache_attribute: Attribute) -> list[int]:
         for dim in range(len(self.padding) // 2):
             shape[-dim - 1] += sum(self.padding[dim * 2 : dim * 2 + 2])
         return shape
@@ -290,9 +315,10 @@ class Padding(Transform):
         return result
 
 
-class Squeeze(Transform):
+class Squeeze(TransformInverse):
 
-    def __init__(self, dim: int) -> None:
+    def __init__(self, dim: int, inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.dim = dim
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -302,10 +328,10 @@ class Squeeze(Transform):
         return tensor.unsqueeze(self.dim)
 
 
-class Resample(Transform, ABC):
+class Resample(TransformInverse, ABC):
 
-    def __init__(self) -> None:
-        pass
+    def __init__(self, inverse: bool) -> None:
+        super().__init__(inverse)
 
     def _resample(self, tensor: torch.Tensor, size: list[int]) -> torch.Tensor:
         if tensor.dtype == torch.uint8:
@@ -326,7 +352,7 @@ class Resample(Transform, ABC):
         pass
 
     @abstractmethod
-    def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
+    def transform_shape(self, name: str, shape: list[int], cache_attribute: Attribute) -> list[int]:
         pass
 
     def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -338,7 +364,8 @@ class Resample(Transform, ABC):
 
 class ResampleToResolution(Resample):
 
-    def __init__(self, spacing: list[float] = [1.0, 1.0, 1.0]) -> None:
+    def __init__(self, spacing: list[float] = [1.0, 1.0, 1.0], inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.spacing = torch.tensor([0 if s < 0 else s for s in spacing])
 
     def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
@@ -349,35 +376,37 @@ class ResampleToResolution(Resample):
             )
         if len(shape) != len(self.spacing):
             TransformError("Shape and spacing dimensions do not match: shape={shape}, spacing={self.spacing}")
-        image_spacing = cache_attribute.get_tensor("Spacing").flip(0)
+        image_spacing = cache_attribute.get_tensor("Spacing")
         spacing = self.spacing
 
         for i, s in enumerate(self.spacing):
             if s == 0:
                 spacing[i] = image_spacing[i]
-        resize_factor = spacing / cache_attribute.get_tensor("Spacing").flip(0)
+        resize_factor = spacing / image_spacing
         return [int(x) for x in (torch.tensor(shape) * 1 / resize_factor)]
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        image_spacing = cache_attribute.get_tensor("Spacing").flip(0)
+        image_spacing = cache_attribute.get_tensor("Spacing")
         spacing = self.spacing
         for i, s in enumerate(self.spacing):
             if s == 0:
                 spacing[i] = image_spacing[i]
-        resize_factor = spacing / cache_attribute.get_tensor("Spacing").flip(0)
-        cache_attribute["Spacing"] = spacing.flip(0)
+        resize_factor = spacing / cache_attribute.get_tensor("Spacing")
+        cache_attribute["Spacing"] = spacing
         cache_attribute["Size"] = np.asarray([int(x) for x in torch.tensor(tensor.shape[1:])])
         size = [int(x) for x in (torch.tensor(tensor.shape[1:]) * 1 / resize_factor)]
         cache_attribute["Size"] = np.asarray(size)
         return self._resample(tensor, size)
 
 
+
 class ResampleToShape(Resample):
 
-    def __init__(self, shape: list[float] = [100, 256, 256]) -> None:
+    def __init__(self, shape: list[float] = [100, 256, 256], inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.shape = torch.tensor([0 if s < 0 else s for s in shape])
 
-    def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
+    def transform_shape(self, name: str, shape: list[int], cache_attribute: Attribute) -> list[int]:
         if "Spacing" not in cache_attribute:
             TransformError(
                 "Missing 'Spacing' in cache attributes, the data is likely not a valid image.",
@@ -407,12 +436,13 @@ class ResampleToShape(Resample):
         return self._resample(tensor, shape)
 
 
-class ResampleTransform(Transform):
+class ResampleTransform(TransformInverse):
 
-    def __init__(self, transforms: dict[str, bool]) -> None:
+    def __init__(self, transforms: dict[str, bool], inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.transforms = transforms
 
-    def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
+    def transform_shape(self, name: str, shape: list[int], cache_attribute: Attribute) -> list[int]:
         return shape
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -485,6 +515,7 @@ class ResampleTransform(Transform):
 class Mask(Transform):
 
     def __init__(self, path: str = "./default.mha", value_outside: int = 0) -> None:
+        super().__init__()
         self.path = path
         self.value_outside = value_outside
 
@@ -501,13 +532,11 @@ class Mask(Transform):
                 raise NameError(f"Mask : {self.path}/{name} not found")
         return torch.where(torch.tensor(mask) > 0, tensor, self.value_outside)
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
 class Gradient(Transform):
 
     def __init__(self, per_dim: bool = False):
+        super().__init__()
         self.per_dim = per_dim
 
     @staticmethod
@@ -541,25 +570,21 @@ class Gradient(Transform):
 
         return result
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
-
 class Argmax(Transform):
 
     def __init__(self, dim: int = 0) -> None:
+        super().__init__()
         self.dim = dim
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         return torch.argmax(tensor, dim=self.dim).unsqueeze(self.dim)
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
 
 
 class FlatLabel(Transform):
 
     def __init__(self, labels: list[int] | None = None) -> None:
+        super().__init__()
         self.labels = labels
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -571,44 +596,36 @@ class FlatLabel(Transform):
             data[torch.where(tensor > 0)] = 1
         return data
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
 class Save(Transform):
 
     def __init__(self, dataset: str) -> None:
+        super().__init__()
         self.dataset = dataset
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         return tensor
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
 class Flatten(Transform):
 
     def __init__(self) -> None:
         super().__init__()
 
-    def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
+    def transform_shape(self, name: str, shape: list[int], cache_attribute: Attribute) -> list[int]:
         return [np.prod(np.asarray(shape))]
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
         return tensor.flatten()
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
 
+class Permute(TransformInverse):
 
-class Permute(Transform):
-
-    def __init__(self, dims: str = "1|0|2") -> None:
-        super().__init__()
+    def __init__(self, dims: str = "1|0|2", inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.dims = [0] + [int(d) + 1 for d in dims.split("|")]
 
-    def transform_shape(self, shape: list[int], cache_attribute: Attribute) -> list[int]:
+    def transform_shape(self, name: str, shape: list[int], cache_attribute: Attribute) -> list[int]:
         return [shape[it - 1] for it in self.dims[1:]]
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -618,10 +635,10 @@ class Permute(Transform):
         return tensor.permute(tuple(np.argsort(self.dims)))
 
 
-class Flip(Transform):
+class Flip(TransformInverse):
 
-    def __init__(self, dims: str = "1|0|2") -> None:
-        super().__init__()
+    def __init__(self, dims: str = "1|0|2", inverse: bool = True) -> None:
+        super().__init__(inverse)
 
         self.dims = [int(d) + 1 for d in str(dims).split("|")]
 
@@ -632,9 +649,10 @@ class Flip(Transform):
         return tensor.flip(tuple(self.dims))
 
 
-class Canonical(Transform):
+class Canonical(TransformInverse):
 
-    def __init__(self) -> None:
+    def __init__(self, inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.canonical_direction = torch.diag(torch.tensor([-1, -1, 1])).to(torch.double)
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -667,6 +685,7 @@ class Canonical(Transform):
 class HistogramMatching(Transform):
 
     def __init__(self, reference_group: str) -> None:
+        super().__init__()
         self.reference_group = reference_group
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -684,13 +703,11 @@ class HistogramMatching(Transform):
         result, _ = image_to_data(matcher.Execute(image, image_ref))
         return torch.tensor(result)
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
-
 
 class SelectLabel(Transform):
 
     def __init__(self, labels: list[str]) -> None:
+        super().__init__()
         self.labels = [label[1:-1].split(",") for label in labels]
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -699,14 +716,11 @@ class SelectLabel(Transform):
             data[tensor == int(old_label)] = int(new_label)
         return data
 
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
 
+class OneHot(TransformInverse):
 
-class OneHot(Transform):
-
-    def __init__(self, num_classes: int) -> None:
-        super().__init__()
+    def __init__(self, num_classes: int, inverse: bool = True) -> None:
+        super().__init__(inverse)
         self.num_classes = num_classes
 
     def __call__(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
@@ -739,7 +753,4 @@ class TotalSegmentator(Transform):
             torch.from_numpy(np.array(np.asanyarray(seg.dataobj), copy=True).astype(np.uint8, copy=False))
             .permute(2, 1, 0)
             .unsqueeze(0)
-        )
-
-    def inverse(self, name: str, tensor: torch.Tensor, cache_attribute: Attribute) -> torch.Tensor:
-        return tensor
+        )

{konfai-1.2.5 → konfai-1.2.7}/konfai/predictor.py

@@ -16,7 +16,7 @@ from torch.utils.tensorboard.writer import SummaryWriter
 from konfai import config_file, konfai_root, models_directory, path_to_models, predictions_directory
 from konfai.data.data_manager import DataPrediction, DatasetIter
 from konfai.data.patching import Accumulator, PathCombine
-from konfai.data.transform import Transform, TransformLoader
+from konfai.data.transform import Transform, TransformInverse, TransformLoader
 from konfai.network.network import CPUModel, ModelLoader, NetState, Network
 from konfai.utils.config import config
 from konfai.utils.dataset import Attribute, Dataset
@@ -226,11 +226,12 @@ class OutSameAsGroupDataset(OutputDataset):
 
         if self.inverse_transform:
             for transform in reversed(dataset.groups_src[self.group_src][self.group_dest].patch_transforms):
-                layer = transform.inverse(
-                    self.names[index_dataset],
-                    layer,
-                    self.attributes[index_dataset][index_augmentation][index_patch],
-                )
+                if isinstance(transform, TransformInverse) and transform.apply_inverse:
+                    layer = transform.inverse(
+                        self.names[index_dataset],
+                        layer,
+                        self.attributes[index_dataset][index_augmentation][index_patch],
+                    )
         self.output_layer_accumulator[index_dataset][index_augmentation].add_layer(index_patch, layer)
 
     def load(self, name_layer: str, datasets: list[Dataset], groups: dict[str, str]):
@@ -277,7 +278,8 @@ class OutSameAsGroupDataset(OutputDataset):
 
         if self.inverse_transform:
             for transform in reversed(dataset.groups_src[self.group_src][self.group_dest].transforms):
-                result = transform.inverse(self.names[index], result, self.attributes[index][0][0])
+                if isinstance(transform, TransformInverse) and transform.apply_inverse:
+                    result = transform.inverse(self.names[index], result, self.attributes[index][0][0])
 
         for transform in self.final_transforms:
             result = transform(self.names[index], result, self.attributes[index][0][0])

{konfai-1.2.5 → konfai-1.2.7}/konfai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konfai
-Version: 1.2.5
+Version: 1.2.7
 Summary: Modular and configurable Deep Learning framework with YAML and PyTorch
 Author-email: Valentin Boussot <boussot.v@gmail.com>
 License-Expression: Apache-2.0
@@ -21,6 +21,7 @@ Requires-Dist: SimpleITK
 Requires-Dist: lxml
 Requires-Dist: h5py
 Requires-Dist: pynvml
+Requires-Dist: requests
 Provides-Extra: vtk
 Requires-Dist: vtk; extra == "vtk"
 Provides-Extra: lpips

{konfai-1.2.5 → konfai-1.2.7}/konfai.egg-info/requires.txt

@@ -8,6 +8,7 @@ SimpleITK
 lxml
 h5py
 pynvml
+requests
 
 [cluster]
 submitit

{konfai-1.2.5 → konfai-1.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "konfai"
-version = "1.2.5"
+version = "1.2.7"
 description = "Modular and configurable Deep Learning framework with YAML and PyTorch"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -24,7 +24,8 @@ dependencies = [
   "SimpleITK",
   "lxml",
   "h5py",
-  "pynvml"
+  "pynvml",
+  "requests"
 ]
 
 [project.urls]