konfai 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

konfai/utils/dataset.py

@@ -1,255 +1,33 @@
-import SimpleITK as sitk
-import h5py
-from abc import ABC, abstractmethod
-import numpy as np
-from typing import Any, Union
+import ast
 import copy
-import torch
-import os
-
-from lxml import etree
 import csv
-from konfai import DATE
-
-class Plot():
-
-    def __init__(self, root: etree.ElementTree) -> None:
-        self.root = root
+import os
+from abc import ABC, abstractmethod
+from typing import Any
 
-    def _explore(root, result, label):
-        if len(root) == 0:
-            for attribute in root.attrib:
-                result["attrib:"+label+":"+attribute] = root.attrib[attribute]
-            if root.text is not None:
-                result[label] = np.fromstring(root.text, sep = ",").astype('double')
-        else:
-            for node in root:
-                Plot._explore(node, result, label+":"+node.tag)
-
-    def getNodes(root, path = None, id = None):
-        nodes = []
-        if path != None:
-            path = path.split(":")
-            for node_name in path:
-                node = root.find(node_name)
-                if node != None:
-                    root = node
-                else:
-                    break
-        if id != None:
-            for node in root.findall(".//"+id):
-                nodes.append(node)
-        else:
-            nodes.append(root)                
-        return nodes
+import h5py
+import numpy as np
+import SimpleITK as sitk  # noqa: N813
+import torch
+from lxml import etree  # nosec B410
 
-    def read(root, path = None, id = None):
-        result = dict()
-        for node in Plot.getNodes(root, path, id):
-            Plot._explore(node, result, etree.ElementTree(root).getpath(node))    
-        return result
+from konfai import current_date
 
-    def _extract(self, ids = [], patients = []):
-        result = dict()
-        if len(patients) == 0:
-            if len(ids) == 0:
-                result.update(Plot.read(self.root,None, None))
-            else:
-                for id in ids:
-                    result.update(Plot.read(self.root, None, id))
-        else:
-            for path in patients:
-                if len(ids) == 0:
-                    result.update(Plot.read(self.root, path, None))
-                else:
-                    for id in ids:
-                        result.update(Plot.read(self.root, path, id))
-        return result
-
-    def getErrors(self, ids = [], patients = []):
-        results = self._extract(ids=ids, patients=patients)
-        errors = {k: v for k, v in results.items() if not k.startswith("attrib:")}
-        results : dict[str, dict[str, np.ndarray]]= {}
-        for key, error in errors.items():
-            patient = key.replace("/",":").split(":")[2]
-            k = key.replace("/",":").split(":")[-1]
-            err = np.linalg.norm(error.reshape(int(error.shape[0]/3),3), ord=2, axis=1)
-            if patient not in results:
-                results[patient] = {k : err}
-            else:
-                results[patient].update({k : err})
-        return results
-    
-    def statistic_attrib(self, ids = [], patients = [], type: str = "HD95Mean"):
-        results = self._extract(ids=ids, patients=patients)
-        
-        errors = {k.replace("attrib:", ""): float(v) for k, v in results.items() if type in k}
-        
-        values = {key : np.array([]) for key in ids}
-        for key, error in errors.items():
-            k = key.replace("/",":").split(":")[-2]
-            values[k] = np.append(values[k], error)
-        
-        for k in values:
-            values[k] = np.mean(values[k])
-        print(values)
-        return values
-    
-    def statistic_parameter(self, ids = [], patients = []):
-        results = self._extract(ids=ids, patients=patients)
-        errors = {k.replace("attrib:", "").replace(":Time", "") : np.load("./Results/{}/{}.npy".format(k.split("/")[3].split(":")[0], k.split("/")[2])) for k in results.keys()}
-        
-        norms = {key : np.array([]) for key in ids}
-        max = 0
-        for key, error in errors.items():
-            if max < int(error.shape[0]/3): 
-                max = int(error.shape[0]/3)
-        
-        for key, error in errors.items():
-            k = key.replace("/",":").split(":")[-1]
-            norms[k] = np.append(norms[k], np.linalg.norm(error.reshape(int(error.shape[0]/3),3), ord=2, axis=1))
-            v = np.linalg.norm(error.reshape(int(error.shape[0]/3),3), ord=2, axis=1)
-
-            print(key, "{} {} {} {} {}".format(np.round(np.mean(v), 2), np.round(np.std(v), 2), np.round(np.quantile(v, 0.25), 2), np.round(np.quantile(v, 0.5), 2), np.round(np.quantile(v, 0.75), 2))) 
-        results = {}
-        for key, values in norms.items():
-            if key == "Rigid":
-                results.update({key : values})
-            else:    
-                try:
-                    name = "{}".format("_".join(key.split("_"))[:-1])
-                    it = int(key.split("_")[-1])
-                except:
-                    name = "{}".format(key.split("-")[0])
-                    it = int(key.split("-")[-1])
-                
-                if name in results:
-                    results[name].update({it : values})
-                else:
-                    results.update({name : {it : values}})
-        
-        r = []
-        for key, values in norms.items():
-            #r.append("{} $\pm$ {}".format(np.round(np.mean(values), 2), np.round(np.std(values), 2))) 
-            r.append("{} {} {}".format(np.round(np.quantile(values, 0.25), 2), np.round(np.quantile(values, 0.5),2), np.round(np.quantile(values, 0.75), 2)))
-            #r.append("{} $\pm$ {}".format(np.round(np.quantile(values, 0.5), 2), np.round(np.quantile(values, 0.75)-np.quantile(values, 0.25), 2)))
-        print(" & ".join(r))
-
-    def statistic(self, ids = [], patients = []):
-        results = self._extract(ids=ids, patients=patients)
-        #errors = {k.replace("attrib:", "").replace(":Time", "") : np.load("./Dataset/{}/{}.npy".format(k.split("/")[3].split(":")[0], k.split("/")[2])) for k in results.keys()}
-        errors = {k: v for k, v in results.items() if not k.startswith("attrib:")}
-        print(errors)
-        norms = {key : np.array([]) for key in ids}
-        max = 0
-        for key, error in errors.items():
-            if max < int(error.shape[0]/3): 
-                max = int(error.shape[0]/3)
-        
-        for key, error in errors.items():
-            k = key.replace("/",":").split(":")[-1]
-            norms[k] = np.append(norms[k], np.linalg.norm(error.reshape(int(error.shape[0]/3),3), ord=2, axis=1))
-            v = np.linalg.norm(error.reshape(int(error.shape[0]/3),3), ord=2, axis=1)
-            print(key, (np.mean(v), np.std(v), np.quantile(v, 0.25), np.quantile(v, 0.5), np.quantile(v, 0.75)) )
-        results = {}
-        """for key, values in norms.items():
-            if key == "Rigid":
-                results.update({key : values})
-            else:    
-                try:
-                    name = "{}".format("_".join(key.split("_"))[:-1])
-                    it = int(key.split("_")[-1])
-                except:
-                    name = "{}".format(key.split("-")[0])
-                    it = int(key.split("-")[-1])
-                
-                if name in results:
-                    results[name].update({it : values})
-                else:
-                    results.update({name : {it : values}})"""
-
-
-        print({key: (np.mean(values), np.std(values), np.quantile(values, 0.25), np.quantile(values, 0.5), np.quantile(values, 0.75)) for key, values in norms.items()})
-        return results
-    
-    def plot(self, ids = [], patients = [], labels = [], colors = None):
-
-        import matplotlib.pyplot as pyplot
-        results = self._extract(ids=ids, patients=patients)
-
-        attrs = {k: v for k, v in results.items() if k.startswith("attrib:")}
-        errors = {k: v for k, v in results.items() if not k.startswith("attrib:")}
-
-        patients = set()
-        max = 0
-        for key, error in errors.items():
-            patients.add(key.replace("/",":").split(":")[2])
-            if max < int(error.shape[0]/3): 
-                max = int(error.shape[0]/3)
-        patients = sorted(patients)
-
-        norms = {patient : np.array([]) for patient in patients}
-        markups = {patient : np.array([]) for patient in patients}
-        series = list()
-        for key, error in errors.items():
-            patient = key.replace("/",":").split(":")[2]
-            markup = np.full((max,3), np.nan)
-            markup[0:int(error.shape[0]/3), :] = error.reshape(int(error.shape[0]/3),3)
-
-            markups[patient] = np.append(markups[patient], markup)
-            norms[patient] = np.append(norms[patient], np.linalg.norm(markup, ord=2, axis=1))
-
-        if len(labels) == 0:
-            labels = list(set([k.split("/")[-1] for k in errors.keys()]))
-
-        for label in labels:
-            series = series+[label]*max
-        import pandas as pd
-        df = pd.DataFrame(dict([(k,pd.Series(v)) for k, v in norms.items()]))
-        df['Categories'] = pd.Series(series)
-        
-        bp = df.boxplot(by='Categories', color="black", figsize=(12,8), notch=True,layout=(1,len(patients)), fontsize=18, rot=0, patch_artist = True, return_type='both',  widths=[0.5]*len(labels))
-
-        color_pallet = {"b" : "paleturquoise", "g" : "lightgreen"}
-        if colors == None:
-            colors = ["b"] * len(patients)
-        pyplot.suptitle('')
-        it_1 = 0
-        for index, (ax,row)  in bp.items():
-            ax.set_xlabel('')
-            ax.set_ylim(ymin=0)
-            ax.set_ylabel("TRE (mm)", fontsize=18)
-            ax.set_yticks([0,1,2,3,4,5,6,7,8,9,10,15,20,25])  # Set label locations.
-            for i,object in enumerate(row["boxes"]):
-                object.set_edgecolor("black")
-                object.set_facecolor(color_pallet[colors[i]])
-                object.set_alpha(0.7)
-                object.set_linewidth(1.0)
-            
-            for i,object in enumerate(row["medians"]):
-                object.set_color("indianred")
-                xy = object.get_xydata()
-                object.set_linewidth(2.0)
-                it_1+=1
-        return self
-    
-    def show(self):
-        import matplotlib.pyplot as pyplot
-        pyplot.show()
 
 class Attribute(dict[str, Any]):
 
-    def __init__(self, attributes : dict[str, Any] = {}) -> None:
+    def __init__(self, attributes: dict[str, Any] | None = None) -> None:
         super().__init__()
+        attributes = attributes or {}
         for k, v in attributes.items():
             super().__setitem__(copy.deepcopy(k), copy.deepcopy(v))
-    
+
     def __getitem__(self, key: str) -> Any:
         i = len([k for k in super().keys() if k.startswith(key)])
-        if i > 0 and "{}_{}".format(key, i-1) in super().keys():   
-            return str(super().__getitem__("{}_{}".format(key, i-1)))
+        if i > 0 and f"{key}_{i - 1}" in super().keys():
+            return str(super().__getitem__(f"{key}_{i - 1}"))
         else:
-            raise NameError("{} not in cache_attribute".format(key))
+            raise NameError(f"{key} not in cache_attribute")
 
     def __setitem__(self, key: str, value: Any) -> None:
         if "_" not in key:
@@ -259,58 +37,63 @@ class Attribute(dict[str, Any]):
                 result = str(value.numpy())
             else:
                 result = str(value)
-            result = result.replace('\n', '')
-            super().__setitem__("{}_{}".format(key, i), result)
+            result = result.replace("\n", "")
+            super().__setitem__(f"{key}_{i}", result)
         else:
             result = None
             if isinstance(value, torch.Tensor):
                 result = str(value.numpy())
             else:
                 result = str(value)
-            result = result.replace('\n', '')
+            result = result.replace("\n", "")
             super().__setitem__(key, result)
 
-    def pop(self, key: str) -> Any:
+    def pop(self, key: str, default: Any = None) -> Any:
         i = len([k for k in super().keys() if k.startswith(key)])
-        if i > 0 and "{}_{}".format(key, i-1) in super().keys():   
-            return super().pop("{}_{}".format(key, i-1))
+        if i > 0 and f"{key}_{i - 1}" in super().keys():
+            return super().pop(f"{key}_{i - 1}")
         else:
-            raise NameError("{} not in cache_attribute".format(key))
+            raise NameError(f"{key} not in cache_attribute")
 
     def get_np_array(self, key) -> np.ndarray:
         return np.fromstring(self[key][1:-1], sep=" ", dtype=np.double)
-    
+
     def get_tensor(self, key) -> torch.Tensor:
         return torch.tensor(self.get_np_array(key)).to(torch.float32)
-    
+
     def pop_np_array(self, key):
         return np.fromstring(self.pop(key)[1:-1], sep=" ", dtype=np.double)
-    
+
     def pop_tensor(self, key) -> torch.Tensor:
         return torch.tensor(self.pop_np_array(key))
-    
-    def __contains__(self, key: str) -> bool:
-        return len([k for k in super().keys() if k.startswith(key)]) > 0
-    
-    def isInfo(self, key: str, value: str) -> bool:
+
+    def __contains__(self, key: object) -> bool:
+        if not isinstance(key, str):
+            return False
+        return any(k.startswith(key) for k in super().keys())
+
+    def is_info(self, key: str, value: str) -> bool:
         return key in self and self[key] == value
 
-def isAnImage(attributes: Attribute):
+
+def is_an_image(attributes: Attribute):
     return "Origin" in attributes and "Spacing" in attributes and "Direction" in attributes
 
-def data_to_image(data : np.ndarray, attributes: Attribute) -> sitk.Image:
-    if not isAnImage(attributes):
+
+def data_to_image(data: np.ndarray, attributes: Attribute) -> sitk.Image:
+    if not is_an_image(attributes):
         raise NameError("Data is not an image")
     if data.shape[0] == 1:
         image = sitk.GetImageFromArray(data[0])
     else:
-        data = data.transpose(tuple([i+1 for i in range(len(data.shape)-1)]+[0]))
+        data = data.transpose(tuple([i + 1 for i in range(len(data.shape) - 1)] + [0]))
         image = sitk.GetImageFromArray(data, isVector=True)
     image.SetOrigin(attributes.get_np_array("Origin").tolist())
     image.SetSpacing(attributes.get_np_array("Spacing").tolist())
     image.SetDirection(attributes.get_np_array("Direction").tolist())
     return image
 
+
 def image_to_data(image: sitk.Image) -> tuple[np.ndarray, Attribute]:
     attributes = Attribute()
     attributes["Origin"] = np.asarray(image.GetOrigin())
@@ -321,81 +104,98 @@ def image_to_data(image: sitk.Image) -> tuple[np.ndarray, Attribute]:
     if image.GetNumberOfComponentsPerPixel() == 1:
         data = np.expand_dims(data, 0)
     else:
-        data = np.transpose(data, (len(data.shape)-1, *[i for i in range(len(data.shape)-1)]))
+        data = np.transpose(data, (len(data.shape) - 1, *list(range(len(data.shape) - 1))))
     return data, attributes
 
-class Dataset():
+
+class Dataset:
 
     class AbstractFile(ABC):
 
+        @abstractmethod
         def __init__(self) -> None:
             pass
-        
+
+        @abstractmethod
         def __enter__(self):
             pass
 
-        def __exit__(self, type, value, traceback):
+        @abstractmethod
+        def __exit__(self, exc_type, value, traceback):
             pass
 
         @abstractmethod
-        def file_to_data(self):
+        def file_to_data(self, group: str, name: str) -> tuple[np.ndarray, Attribute]:
             pass
 
         @abstractmethod
-        def data_to_file(self):
+        def data_to_file(
+            self,
+            name: str,
+            data: sitk.Image | sitk.Transform | np.ndarray,
+            attributes: Attribute | None = None,
+        ) -> None:
             pass
 
         @abstractmethod
-        def getNames(self, group: str) -> list[str]:
+        def get_names(self, group: str) -> list[str]:
             pass
-        
+
         @abstractmethod
-        def getGroup(self) -> list[str]:
+        def get_group(self) -> list[str]:
             pass
 
         @abstractmethod
-        def isExist(self, group: str, name: Union[str, None] = None) -> bool:
+        def is_exist(self, group: str, name: str | None = None) -> bool:
             pass
-        
+
         @abstractmethod
-        def getInfos(self, group: Union[str, None], name: str) -> tuple[list[int], Attribute]:
+        def get_infos(self, group: str, name: str) -> tuple[list[int], Attribute]:
             pass
 
     class H5File(AbstractFile):
 
         def __init__(self, filename: str, read: bool) -> None:
-            self.h5: Union[h5py.File, None] = None
+            self.h5: h5py.File | None = None
             self.filename = filename
             if not self.filename.endswith(".h5"):
                 self.filename += ".h5"
             self.read = read
 
         def __enter__(self):
-            args = {}
             if self.read:
-                self.h5 = h5py.File(self.filename, 'r', **args)
+                self.h5 = h5py.File(self.filename, "r")
             else:
                 if not os.path.exists(self.filename):
-                    if len(self.filename.split("/")) > 1 and not os.path.exists("/".join(self.filename.split("/")[:-1])):
+                    if len(self.filename.split("/")) > 1 and not os.path.exists(
+                        "/".join(self.filename.split("/")[:-1])
+                    ):
                         os.makedirs("/".join(self.filename.split("/")[:-1]))
-                    self.h5 = h5py.File(self.filename, 'w', **args)
-                else: 
-                    self.h5 = h5py.File(self.filename, 'r+', **args)
-                self.h5.attrs["Date"] = DATE()
+                    self.h5 = h5py.File(self.filename, "w")
+                else:
+                    self.h5 = h5py.File(self.filename, "r+")
+                self.h5.attrs["Date"] = current_date()
             self.h5.__enter__()
             return self.h5
-    
-        def __exit__(self, type, value, traceback):
+
+        def __exit__(self, exc_type, value, traceback):
             if self.h5 is not None:
                 self.h5.close()
-        
+
         def file_to_data(self, groups: str, name: str) -> tuple[np.ndarray, Attribute]:
-            dataset = self._getDataset(groups, name)
+            dataset = self._get_dataset(groups, name)
             data = np.zeros(dataset.shape, dataset.dtype)
             dataset.read_direct(data)
-            return data, Attribute({k : str(v) for k, v in dataset.attrs.items()})
-
-        def data_to_file(self, name : str, data : Union[sitk.Image, sitk.Transform, np.ndarray], attributes : Union[Attribute, None] = None) -> None:
+            return data, Attribute({k: str(v) for k, v in dataset.attrs.items()})
+
+        def data_to_file(
+            self,
+            name: str,
+            data: sitk.Image | sitk.Transform | np.ndarray,
+            attributes: Attribute | None = None,
+        ) -> None:
+            if self.h5 is None:
+                return
             if attributes is None:
                 attributes = Attribute()
             if isinstance(data, sitk.Image):
@@ -405,7 +205,7 @@ class Dataset():
                 transforms = []
                 if isinstance(data, sitk.CompositeTransform):
                     for i in range(data.GetNumberOfTransforms()):
-                        transforms.append(data.GetNthTransform(i))    
+                        transforms.append(data.GetNthTransform(i))
                 else:
                     transforms.append(data)
                 datas = []
@@ -416,8 +216,8 @@ class Dataset():
                         transform_type = "AffineTransform_double_3_3"
                     if isinstance(transform, sitk.BSplineTransform):
                         transform_type = "BSplineTransform_double_3_3"
-                    attributes["{}:Transform".format(i)] = transform_type
-                    attributes["{}:FixedParameters".format(i)] = transform.GetFixedParameters()
+                    attributes[f"{i}:Transform"] = transform_type
+                    attributes[f"{i}:FixedParameters"] = transform.GetFixedParameters()
 
                     datas.append(np.asarray(transform.GetParameters()))
                 data = np.asarray(datas)
@@ -434,38 +234,41 @@ class Dataset():
                 del h5_group[name]
 
             dataset = h5_group.create_dataset(name, data=data, dtype=data.dtype, chunks=None)
-            dataset.attrs.update({k : str(v) for k, v in attributes.items()})
-        
-        def isExist(self, group: str, name: Union[str, None] = None) -> bool:
-            if group in self.h5:
-                if isinstance(self.h5[group], h5py.Dataset):
-                    return True
-                elif name is not None:
-                    return name in self.h5[group]
-                else:
-                    return False
+            dataset.attrs.update({k: str(v) for k, v in attributes.items()})
+
+        def is_exist(self, group: str, name: str | None = None) -> bool:
+            if self.h5 is not None:
+                if group in self.h5:
+                    if isinstance(self.h5[group], h5py.Dataset):
+                        return True
+                    elif name is not None:
+                        return name in self.h5[group]
+                    else:
+                        return False
             return False
 
-        def getNames(self, groups: str, h5_group: h5py.Group = None) -> list[str]:
+        def get_names(self, groups: str, h5_group: h5py.Group = None) -> list[str]:
             names = []
             if h5_group is None:
                 h5_group = self.h5
             group = groups.split("/")[0]
             if group == "":
-                names = [dataset.name.split("/")[-1] for dataset in h5_group.values() if isinstance(dataset, h5py.Dataset)]
+                names = [
+                    dataset.name.split("/")[-1] for dataset in h5_group.values() if isinstance(dataset, h5py.Dataset)
+                ]
             elif group == "*":
                 for k in h5_group.keys():
                     if isinstance(h5_group[k], h5py.Group):
-                        names.extend(self.getNames("/".join(groups.split("/")[1:]), h5_group[k]))
+                        names.extend(self.get_names("/".join(groups.split("/")[1:]), h5_group[k]))
             else:
                 if group in h5_group:
-                    names.extend(self.getNames("/".join(groups.split("/")[1:]), h5_group[group]))
+                    names.extend(self.get_names("/".join(groups.split("/")[1:]), h5_group[group]))
             return names
-        
-        def getGroup(self):
-            return self.h5.keys()
-        
-        def _getDataset(self, groups: str, name: str, h5_group: h5py.Group = None) -> h5py.Dataset:
+
+        def get_group(self) -> list[str]:
+            return list(self.h5.keys()) if self.h5 is not None else []
+
+        def _get_dataset(self, groups: str, name: str, h5_group: h5py.Group = None) -> h5py.Dataset:
             if h5_group is None:
                 h5_group = self.h5
             if groups != "":
@@ -479,39 +282,42 @@ class Dataset():
             elif group == "*":
                 for k in h5_group.keys():
                     if isinstance(h5_group[k], h5py.Group):
-                        result_tmp = self._getDataset("/".join(groups.split("/")[1:]), name, h5_group[k])
+                        result_tmp = self._get_dataset("/".join(groups.split("/")[1:]), name, h5_group[k])
                         if result_tmp is not None:
                             result = result_tmp
             else:
                 if group in h5_group:
-                    result_tmp = self._getDataset("/".join(groups.split("/")[1:]), name, h5_group[group])
+                    result_tmp = self._get_dataset("/".join(groups.split("/")[1:]), name, h5_group[group])
                     if result_tmp is not None:
                         result = result_tmp
             return result
-        
-        def getInfos(self, groups: str, name: str) -> tuple[list[int], Attribute]:
-            dataset = self._getDataset(groups, name)
-            return (dataset.shape, Attribute({k : str(v) for k, v in dataset.attrs.items()}))
-        
+
+        def get_infos(self, groups: str, name: str) -> tuple[list[int], Attribute]:
+            dataset = self._get_dataset(groups, name)
+            return (
+                dataset.shape,
+                Attribute({k: str(v) for k, v in dataset.attrs.items()}),
+            )
+
     class SitkFile(AbstractFile):
 
-        def __init__(self, filename: str, read: bool, format: str) -> None:
+        def __init__(self, filename: str, read: bool, file_format: str) -> None:
             self.filename = filename
             self.read = read
-            self.format = format
-     
+            self.file_format = file_format
+
         def file_to_data(self, group: str, name: str) -> tuple[np.ndarray, Attribute]:
             attributes = Attribute()
-            if os.path.exists("{}{}.{}".format(self.filename, name, self.format)):
-                image = sitk.ReadImage("{}{}.{}".format(self.filename, name, self.format))
+            if os.path.exists(f"{self.filename}{name}.{self.file_format}"):
+                image = sitk.ReadImage(f"{self.filename}{name}.{self.file_format}")
                 data, attributes_tmp = image_to_data(image)
                 attributes.update(attributes_tmp)
-            elif os.path.exists("{}{}.itk.txt".format(self.filename, name)): 
-                data = sitk.ReadTransform("{}{}.itk.txt".format(self.filename, name))
+            elif os.path.exists(f"{self.filename}{name}.itk.txt"):
+                data = sitk.ReadTransform(f"{self.filename}{name}.itk.txt")
                 transforms = []
                 if isinstance(data, sitk.CompositeTransform):
                     for i in range(data.GetNumberOfTransforms()):
-                        transforms.append(data.GetNthTransform(i))    
+                        transforms.append(data.GetNthTransform(i))
                 else:
                     transforms.append(data)
                 datas = []
@@ -522,113 +328,151 @@ class Dataset():
                         transform_type = "AffineTransform_double_3_3"
                     if isinstance(transform, sitk.BSplineTransform):
                         transform_type = "BSplineTransform_double_3_3"
-                    attributes["{}:Transform".format(i)] = transform_type
-                    attributes["{}:FixedParameters".format(i)] = transform.GetFixedParameters()
+                    attributes[f"{i}:Transform"] = transform_type
+                    attributes[f"{i}:FixedParameters"] = transform.GetFixedParameters()
 
                     datas.append(np.asarray(transform.GetParameters()))
                 data = np.asarray(datas)
-            elif os.path.exists("{}{}.fcsv".format(self.filename, name)):
-                with open("{}{}.fcsv".format(self.filename, name), newline="") as csvfile:
-                    reader = csv.reader(filter(lambda row: row[0]!='#', csvfile))
+            elif os.path.exists(f"{self.filename}{name}.fcsv"):
+                with open(f"{self.filename}{name}.fcsv", newline="") as csvfile:
+                    reader = csv.reader(filter(lambda row: row[0] != "#", csvfile))
                     lines = list(reader)
                     data = np.zeros((len(list(lines)), 3), dtype=np.double)
                     for i, row in enumerate(lines):
                         data[i] = np.array(row[1:4], dtype=np.double)
                     csvfile.close()
-            elif os.path.exists("{}{}.xml".format(self.filename, name)):
-                with open("{}{}.xml".format(self.filename, name), 'rb') as xml_file:
-                    result = etree.parse(xml_file, etree.XMLParser(remove_blank_text=True)).getroot()
+            elif os.path.exists(f"{self.filename}{name}.xml"):
+                with open(f"{self.filename}{name}.xml", "rb") as xml_file:
+                    result = etree.parse(xml_file, etree.XMLParser(remove_blank_text=True)).getroot()  # nosec B320
                     xml_file.close()
                     return result
-            elif os.path.exists("{}{}.vtk".format(self.filename, name)):
+            elif os.path.exists(f"{self.filename}{name}.vtk"):
                 import vtk
-                vtkReader = vtk.vtkPolyDataReader()
-                vtkReader.SetFileName("{}{}.vtk".format(self.filename, name))
-                vtkReader.Update()
+
+                vtk_reader = vtk.vtkPolyDataReader()
+                vtk_reader.SetFileName(f"{self.filename}{name}.vtk")
+                vtk_reader.Update()
                 data = []
-                points = vtkReader.GetOutput().GetPoints()
+                points = vtk_reader.GetOutput().GetPoints()
                 num_points = points.GetNumberOfPoints()
                 for i in range(num_points):
                     data.append(list(points.GetPoint(i)))
                 data = np.asarray(data)
-            elif os.path.exists("{}{}.npy".format(self.filename, name)):
-                data = np.load("{}{}.npy".format(self.filename, name))
+            elif os.path.exists(f"{self.filename}{name}.npy"):
+                data = np.load(f"{self.filename}{name}.npy")
             return data, attributes
-        
+
         def is_vtk_polydata(self, obj):
             try:
                 import vtk
+
                 return isinstance(obj, vtk.vtkPolyData)
             except ImportError:
                 return False
-                
-        def data_to_file(self, name : str, data : Union[sitk.Image, sitk.Transform, np.ndarray], attributes : Attribute = Attribute()) -> None:
+
+        def __enter__(self):
+            pass
+
+        def __exit__(self, exc_type, value, traceback):
+            pass
+
+        def data_to_file(
+            self,
+            name: str,
+            data: sitk.Image | sitk.Transform | np.ndarray,
+            attributes: Attribute | None = None,
+        ) -> None:
+            if attributes is None:
+                attributes = Attribute()
             if not os.path.exists(self.filename):
                 os.makedirs(self.filename)
             if isinstance(data, sitk.Image):
                 for k, v in attributes.items():
                     data.SetMetaData(k, v)
-                sitk.WriteImage(data, "{}{}.{}".format(self.filename, name, self.format))
+                sitk.WriteImage(data, f"{self.filename}{name}.{self.file_format}")
             elif isinstance(data, sitk.Transform):
-                sitk.WriteTransform(data, "{}{}.itk.txt".format(self.filename, name))
+                sitk.WriteTransform(data, f"{self.filename}{name}.itk.txt")
             elif self.is_vtk_polydata(data):
                 import vtk
-                vtkWriter = vtk.vtkPolyDataWriter()
-                vtkWriter.SetFileName("{}{}.vtk".format(self.filename, name))
-                vtkWriter.SetInputData(data)
-                vtkWriter.Write()
-            elif isAnImage(attributes):   
+
+                vtk_writer = vtk.vtkPolyDataWriter()
+                vtk_writer.SetFileName(f"{self.filename}{name}.vtk")
+                vtk_writer.SetInputData(data)
+                vtk_writer.Write()
+            elif is_an_image(attributes):
                 self.data_to_file(name, data_to_image(data, attributes), attributes)
-            elif (len(data.shape) == 2 and data.shape[1] == 3 and data.shape[0] > 0):
+            elif len(data.shape) == 2 and data.shape[1] == 3 and data.shape[0] > 0:
                 data = np.round(data, 4)
-                with open("{}{}.fcsv".format(self.filename, name), 'w') as f:
-                    f.write("# Markups fiducial file version = 4.6\n# CoordinateSystem = 0\n# columns = id,x,y,z,ow,ox,oy,oz,vis,sel,lock,label,desc,associatedNodeID\n")
+                with open(f"{self.filename}{name}.fcsv", "w") as f:
+                    f.write(
+                        "# Markups fiducial file version = 4.6\n# CoordinateSystem = 0\n#"
+                        " columns = id,x,y,z,ow,ox,oy,oz,vis,sel,lock,label,desc,associatedNodeID\n",
+                    )
                     for i in range(data.shape[0]):
-                        f.write("vtkMRMLMarkupsFiducialNode_"+str(i+1)+","+str(data[i, 0])+","+str(data[i, 1])+","+str(data[i, 2])+",0,0,0,1,1,1,0,F-"+str(i+1)+",,vtkMRMLScalarVolumeNode1\n")
+                        f.write(
+                            "vtkMRMLMarkupsFiducialNode_"
+                            + str(i + 1)
+                            + ","
+                            + str(data[i, 0])
+                            + ","
+                            + str(data[i, 1])
+                            + ","
+                            + str(data[i, 2])
+                            + ",0,0,0,1,1,1,0,F-"
+                            + str(i + 1)
+                            + ",,vtkMRMLScalarVolumeNode1\n"
+                        )
                     f.close()
             elif "path" in attributes:
-                if os.path.exists("{}{}.xml".format(self.filename, name)):
-                    with open("{}{}.xml".format(self.filename, name), 'rb') as xml_file:
-                        root = etree.parse(xml_file, etree.XMLParser(remove_blank_text=True)).getroot()
+                if os.path.exists(f"{self.filename}{name}.xml"):
+                    with open(f"{self.filename}{name}.xml", "rb") as xml_file:
+                        root = etree.parse(xml_file, etree.XMLParser(remove_blank_text=True)).getroot()  # nosec B320
                         xml_file.close()
                 else:
                     root = etree.Element(name)
                 node = root
-                path = attributes["path"].split(':')
+                path = attributes["path"].split(":")
 
                 for node_name in path:
                     node_tmp = node.find(node_name)
-                    if node_tmp == None:
+                    if node_tmp is None:
                         node_tmp = etree.SubElement(node, node_name)
                         node.append(node_tmp)
                     node = node_tmp
-                if attributes != None:
+                if attributes is not None:
                     for attribute_tmp in attributes.keys():
                         attribute = "_".join(attribute_tmp.split("_")[:-1])
                         if attribute != "path":
                             node.set(attribute, attributes[attribute])
                 if data.size > 0:
-                    node.text = ", ".join(map(str, data.flatten())) #np.array2string(data, separator=',')[1:-1].replace('\n','')
-                with open("{}{}.xml".format(self.filename, name), 'wb') as f:
-                    f.write(etree.tostring(root, pretty_print=True, encoding='utf-8'))
+                    node.text = ", ".join(
+                        map(str, data.flatten())
+                    )  # np.array2string(data, separator=',')[1:-1].replace('\n','')
+                with open(f"{self.filename}{name}.xml", "wb") as f:
+                    f.write(etree.tostring(root, pretty_print=True, encoding="utf-8"))
                     f.close()
             else:
-                np.save("{}{}.npy".format(self.filename, name), data)
-                 
-        def isExist(self, group: str, name: Union[str, None] = None) -> bool:
-            return os.path.exists("{}{}.{}".format(self.filename, group, self.format)) or os.path.exists("{}{}.itk.txt".format(self.filename, group)) or os.path.exists("{}{}.fcsv".format(self.filename, group)) or os.path.exists("{}{}.npy".format(self.filename, group))
-        
-        def getNames(self, group: str) -> list[str]:
+                np.save(f"{self.filename}{name}.npy", data)
+
+        def is_exist(self, group: str, name: str | None = None) -> bool:
+            return (
+                os.path.exists(f"{self.filename}{group}.{self.file_format}")
+                or os.path.exists(f"{self.filename}{group}.itk.txt")
+                or os.path.exists(f"{self.filename}{group}.fcsv")
+                or os.path.exists(f"{self.filename}{group}.npy")
+            )
+
+        def get_names(self, group: str) -> list[str]:
             raise NotImplementedError()
-        
-        def getGroup(self):
+
+        def get_group(self):
             raise NotImplementedError()
-        
-        def getInfos(self, group: str, name: str) -> tuple[list[int], Attribute]:
+
+        def get_infos(self, group: str, name: str) -> tuple[list[int], Attribute]:
             attributes = Attribute()
-            if os.path.exists("{}{}{}.{}".format(self.filename, group if group is not None else "", name, self.format)):
+            if os.path.exists(f"{self.filename}{group if group is not None else ''}{name}.{self.file_format}"):
                 file_reader = sitk.ImageFileReader()
-                file_reader.SetFileName("{}{}{}.{}".format(self.filename, group if group is not None else "", name, self.format))
+                file_reader.SetFileName(f"{self.filename}{group if group is not None else ''}{name}.{self.file_format}")
                 file_reader.ReadImageInformation()
                 attributes["Origin"] = np.asarray(file_reader.GetOrigin())
                 attributes["Spacing"] = np.asarray(file_reader.GetSpacing())
@@ -638,72 +482,85 @@ class Dataset():
                 size = list(file_reader.GetSize())
                 if len(size) == 3:
                     size = list(reversed(size))
-                size = [file_reader.GetNumberOfComponents()]+size
+                size = [file_reader.GetNumberOfComponents()] + size
             else:
                 data, attributes = self.file_to_data(group if group is not None else "", name)
                 size = data.shape
-            return tuple(size), attributes
+            return size, attributes
 
-    class File(ABC):
+    class File:
 
-        def __init__(self, filename: str, read: bool, format: str) -> None:
+        def __init__(self, filename: str, read: bool, file_format: str) -> None:
             self.filename = filename
             self.read = read
-            self.file = None
-            self.format = format
+            self.file: "Dataset.AbstractFile" | None = None
+            self.file_format = file_format
 
-        def __enter__(self):
-            if self.format == "h5":
+        def __enter__(self) -> "Dataset.AbstractFile":
+            if self.file_format == "h5":
                 self.file = Dataset.H5File(self.filename, self.read)
             else:
-                self.file = Dataset.SitkFile(self.filename+"/", self.read, self.format)
+                self.file = Dataset.SitkFile(self.filename + "/", self.read, self.file_format)
             self.file.__enter__()
             return self.file
 
-        def __exit__(self, type, value, traceback):
-            self.file.__exit__(type, value, traceback)
+        def __exit__(self, exc_type, value, traceback):
+            if self.file is not None:
+                self.file.__exit__(exc_type, value, traceback)
 
-    def __init__(self, filename : str, format: str) -> None:
-        if format != "h5" and not filename.endswith("/"):
-            filename = "{}/".format(filename)
-        self.is_directory = filename.endswith("/") 
+    def __init__(self, filename: str, file_format: str) -> None:
+        if file_format != "h5" and not filename.endswith("/"):
+            filename = f"{filename}/"
+        self.is_directory = filename.endswith("/")
         self.filename = filename
-        self.format = format
-        
-    def write(self, group : str, name : str, data : Union[sitk.Image, sitk.Transform, np.ndarray], attributes : Attribute = Attribute()):
+        self.file_format = file_format
+
+    def write(
+        self,
+        group: str,
+        name: str,
+        data: sitk.Image | sitk.Transform | np.ndarray,
+        attributes: Attribute | None = None,
+    ):
+        if attributes is None:
+            attributes = Attribute()
         if self.is_directory:
             if not os.path.exists(self.filename):
                 os.makedirs(self.filename)
         if self.is_directory:
             s_group = group.split("/")
             if len(s_group) > 1:
-                subDirectory = "/".join(s_group[:-1])
-                name = "{}/{}".format(subDirectory, name)
+                sub_directory = "/".join(s_group[:-1])
+                name = f"{sub_directory}/{name}"
                 group = s_group[-1]
-            with Dataset.File("{}{}".format(self.filename, name), False, self.format) as file:
+            with Dataset.File(f"{self.filename}{name}", False, self.file_format) as file:
                 file.data_to_file(group, data, attributes)
         else:
-            with Dataset.File(self.filename, False, self.format) as file:
-                file.data_to_file("{}/{}".format(group, name), data, attributes)
-    
-    def readData(self, groups : str, name : str) -> tuple[np.ndarray, Attribute]:
+            with Dataset.File(self.filename, False, self.file_format) as file:
+                file.data_to_file(f"{group}/{name}", data, attributes)
+
+    def read_data(self, groups: str, name: str) -> tuple[np.ndarray, Attribute]:
         if not os.path.exists(self.filename):
-            raise NameError("Dataset {} not found".format(self.filename))
+            raise NameError(f"Dataset {self.filename} not found")
         if self.is_directory:
-            for subDirectory in self._getSubDirectories(groups):
+            for sub_directory in self._get_sub_directories(groups):
                 group = groups.split("/")[-1]
-                if os.path.exists("{}{}{}{}".format(self.filename, subDirectory, name, ".h5" if self.format == "h5" else "")):
-                    with Dataset.File("{}{}{}".format(self.filename, subDirectory, name), False, self.format) as file:
+                if os.path.exists(f"{self.filename}{sub_directory}{name}{'.h5' if self.file_format == 'h5' else ''}"):
+                    with Dataset.File(
+                        f"{self.filename}{sub_directory}{name}",
+                        False,
+                        self.file_format,
+                    ) as file:
                         result = file.file_to_data("", group)
         else:
-            with Dataset.File(self.filename, False, self.format) as file:
+            with Dataset.File(self.filename, False, self.file_format) as file:
                 result = file.file_to_data(groups, name)
         return result
-    
-    def readTransform(self, group : str, name : str) -> sitk.Transform:
+
+    def read_transform(self, group: str, name: str) -> sitk.Transform:
         if not os.path.exists(self.filename):
-            raise NameError("Dataset {} not found".format(self.filename))
-        transformParameters, attribute = self.readData(group, name)
+            raise NameError(f"Dataset {self.filename} not found")
+        transform_parameters, attribute = self.read_data(group, name)
         transforms_type = [v for k, v in attribute.items() if k.endswith(":Transform_0")]
         transforms = []
         for i, transform_type in enumerate(transforms_type):
@@ -713,78 +570,92 @@ class Dataset():
                 transform = sitk.AffineTransform(3)
             if transform_type == "BSplineTransform_double_3_3":
                 transform = sitk.BSplineTransform(3)
-            transform.SetFixedParameters(eval(attribute["{}:FixedParameters".format(i)]))
-            transform.SetParameters(tuple(transformParameters[i]))
+            transform.SetFixedParameters(ast.literal_eval(attribute[f"{i}:FixedParameters"]))
+            transform.SetParameters(tuple(transform_parameters[i]))
             transforms.append(transform)
         return sitk.CompositeTransform(transforms) if len(transforms) > 1 else transforms[0]
 
-    def readImage(self, group : str, name : str):
-         data, attribute = self.readData(group, name)
-         return data_to_image(data, attribute)
-            
-    def getSize(self, group: str) -> int:
-        return len(self.getNames(group))
-    
-    def isGroupExist(self, group: str) -> bool:
-        return self.getSize(group) > 0
-    
-    def isDatasetExist(self, group: str, name: str) -> bool:
-        return name in self.getNames(group)
-    
-    def _getSubDirectories(self, groups: str, subDirectory: str = ""):
+    def read_image(self, group: str, name: str):
+        data, attribute = self.read_data(group, name)
+        return data_to_image(data, attribute)
+
+    def get_size(self, group: str) -> int:
+        return len(self.get_names(group))
+
+    def is_group_exist(self, group: str) -> bool:
+        return self.get_size(group) > 0
+
+    def is_dataset_exist(self, group: str, name: str) -> bool:
+        return name in self.get_names(group)
+
+    def _get_sub_directories(self, groups: str, sub_directory: str = ""):
         group = groups.split("/")[0]
-        subDirectories = []
+        sub_directories = []
         if len(groups.split("/")) == 1:
-            subDirectories.append(subDirectory)
+            sub_directories.append(sub_directory)
         elif group == "*":
-            for k in os.listdir("{}{}".format(self.filename, subDirectory)):
-                if not os.path.isfile("{}{}{}".format(self.filename, subDirectory, k)):
-                    subDirectories.extend(self._getSubDirectories("/".join(groups.split("/")[1:]), "{}{}/".format(subDirectory , k)))
+            for k in os.listdir(f"{self.filename}{sub_directory}"):
+                if not os.path.isfile(f"{self.filename}{sub_directory}{k}"):
+                    sub_directories.extend(
+                        self._get_sub_directories(
+                            "/".join(groups.split("/")[1:]),
+                            f"{sub_directory}{k}/",
+                        )
+                    )
         else:
-            subDirectory = "{}{}/".format(subDirectory, group)
-            if os.path.exists("{}{}".format(self.filename, subDirectory)):
-                subDirectories.extend(self._getSubDirectories("/".join(groups.split("/")[1:]), subDirectory))
-        return subDirectories
+            sub_directory = f"{sub_directory}{group}/"
+            if os.path.exists(f"{self.filename}{sub_directory}"):
+                sub_directories.extend(self._get_sub_directories("/".join(groups.split("/")[1:]), sub_directory))
+        return sub_directories
 
-    def getNames(self, groups: str, index: Union[list[int], None] = None) -> list[str]:
+    def get_names(self, groups: str, index: list[int] | None = None) -> list[str]:
         names = []
         if self.is_directory:
-            for subDirectory in self._getSubDirectories(groups):
+            for sub_directory in self._get_sub_directories(groups):
                 group = groups.split("/")[-1]
-                if os.path.exists("{}{}".format(self.filename, subDirectory)):
-                    for name in sorted(os.listdir("{}{}".format(self.filename, subDirectory))):
-                        if os.path.isfile("{}{}{}".format(self.filename, subDirectory, name)) or self.format != "h5":
-                            with Dataset.File("{}{}{}".format(self.filename, subDirectory, name), True, self.format) as file:
-                                if file.isExist(group):
-                                    names.append(name.replace(".h5", "") if self.format == "h5" else name)
+                if os.path.exists(f"{self.filename}{sub_directory}"):
+                    for name in sorted(os.listdir(f"{self.filename}{sub_directory}")):
+                        if os.path.isfile(f"{self.filename}{sub_directory}{name}") or self.file_format != "h5":
+                            with Dataset.File(
+                                f"{self.filename}{sub_directory}{name}",
+                                True,
+                                self.file_format,
+                            ) as file:
+                                if file.is_exist(group):
+                                    names.append(name.replace(".h5", "") if self.file_format == "h5" else name)
         else:
-            with Dataset.File(self.filename, True, self.format) as file:
-                names = file.getNames(groups)
+            with Dataset.File(self.filename, True, self.file_format) as file:
+                names = file.get_names(groups)
         return [name for i, name in enumerate(sorted(names)) if index is None or i in index]
-    
-    def getGroup(self):
+
+    def get_group(self):
         if self.is_directory:
-            groups = set()
+            groups_set = set()
             for root, _, files in os.walk(self.filename):
                 for file in files:
                     path = os.path.relpath(os.path.join(root, file.split(".")[0]), self.filename)
                     parts = path.split("/")
                     if len(parts) >= 2:
                         del parts[-2]
-                    groups.add("/".join(parts))
+                    groups_set.add("/".join(parts))
+            groups = list(groups_set)
         else:
-            with Dataset.File(self.filename, True, self.format) as file:
-                groups = file.getGroup()
+            with Dataset.File(self.filename, True, self.file_format) as dataset_file:
+                groups = dataset_file.get_group()
         return list(groups)
-    
-    def getInfos(self, groups: str, name: str) -> tuple[list[int], Attribute]:
+
+    def get_infos(self, groups: str, name: str) -> tuple[list[int], Attribute]:
         if self.is_directory:
-            for subDirectory in self._getSubDirectories(groups):
+            for sub_directory in self._get_sub_directories(groups):
                 group = groups.split("/")[-1]
-                if os.path.exists("{}{}{}{}".format(self.filename, subDirectory, name, ".h5" if self.format == "h5" else "")):
-                    with Dataset.File("{}{}{}".format(self.filename, subDirectory, name), True, self.format) as file:
-                        result = file.getInfos("", group)      
+                if os.path.exists(f"{self.filename}{sub_directory}{name}{'.h5' if self.file_format == 'h5' else ''}"):
+                    with Dataset.File(
+                        f"{self.filename}{sub_directory}{name}",
+                        True,
+                        self.file_format,
+                    ) as file:
+                        result = file.get_infos("", group)
         else:
-            with Dataset.File(self.filename, True, self.format) as file:
-                result = file.getInfos(groups, name)
-        return result
+            with Dataset.File(self.filename, True, self.file_format) as file:
+                result = file.get_infos(groups, name)
+        return result