From 0c52327d2ba0683af81d45f603d846f3a795ef75 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Wed, 19 Apr 2023 15:31:57 +0200
Subject: [PATCH 1/3] Ajout de la fonction de calcul de la taille d'une
 pyramide

---
 CHANGELOG.md          |  11 ++-
 src/rok4/Pyramid.py   | 152 +++++++++++++++++++++++++-----------------
 src/rok4/Storage.py   | 133 ++++++++++++++++++++++++++++--------
 tests/test_Storage.py | 138 ++++++++++++++++++++++++++++----------
 4 files changed, 302 insertions(+), 132 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a24c5b..a70a79d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,20 +1,17 @@
 ## Summary
 
-Lecture facilitée de la liste d'une pyramide.
+Calcul de la taille d'une pyramide
 
 ## Changelog
 
 ### [Added]
 
 * Pyramid
-    * Fonctions de gestion de la liste : chargement et lecture (via un generator)
-    * Taille du header d'une dalle stockée dans la variable `ROK4_IMAGE_HEADER_SIZE`
-    * La proriété `tile_extension` : retourne l'extension d'une tuile de la pyramide en fonction du format
-    * Des exemples d'utilisation des fonctions principales
-### [Fixed]
+    * Fonction de calcul de la taille d'une pyramide
 
 * Storage
-    * Lecture de la taille d'un objet S3 : pas besoin d'enlever des quotes dans le header `Content-Length`
+    * Fonction de calcul de la taille des fichiers d'un chemin selon le stockage
+
 <!--
 ### [Added]
 
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index bc9e669..2f5aa9f 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -81,7 +81,7 @@ def b36_path_decode(path: str) -> Tuple[int, int]:
 
     Returns:
         Tuple[int, int]: slab's column and row
-    """    
+    """
 
     path = path.replace('/', '')
     path = re.sub(r'(\.TIFF?)', "", path.upper())
@@ -107,7 +107,7 @@ def b36_path_encode(column: int, row: int, slashs: int) -> str:
 
     Returns:
         str: base-36 based path
-    """    
+    """
 
     b36_column = b36_number_encode(column)
     b36_row = b36_number_encode(row)
@@ -156,7 +156,7 @@ def from_descriptor(cls, data: Dict, pyramid: 'Pyramid') -> 'Level':
 
         Returns:
             Pyramid: a Level instance
-        """    
+        """
         level = cls()
 
         level.__pyramid = pyramid
@@ -171,9 +171,9 @@ def from_descriptor(cls, data: Dict, pyramid: 'Pyramid') -> 'Level':
             if pyramid.storage_type.name != data["storage"]["type"]:
                 raise Exception(f"Pyramid {pyramid.descriptor} owns levels using different storage types ({ data['storage']['type'] }) than its one ({pyramid.storage_type.name})")
 
-            if pyramid.storage_type == StorageType.FILE:                    
-                pyramid.storage_depth = data["storage"]["path_depth"]   
-            
+            if pyramid.storage_type == StorageType.FILE:
+                pyramid.storage_depth = data["storage"]["path_depth"]
+
             if "mask_directory" in data["storage"] or "mask_prefix" in data["storage"]:
                 if not pyramid.own_masks:
                     raise Exception(f"Pyramid {pyramid.__descriptor} does not define a mask format but level {level.__id} define mask storage informations")
@@ -229,12 +229,12 @@ def __str__(self) -> str:
 
 
     @property
-    def serializable(self) -> Dict: 
+    def serializable(self) -> Dict:
         """Get the dict version of the pyramid object, pyramid's descriptor compliant
 
         Returns:
             Dict: pyramid's descriptor structured object description
-        """   
+        """
         serialization = {
             "id": self.__id,
             "tiles_per_width": self.__slab_size[0],
@@ -275,16 +275,16 @@ def serializable(self) -> Dict:
         return serialization
 
     @property
-    def id(self) -> str: 
+    def id(self) -> str:
         return self.__id
 
     @property
-    def bbox(self) -> Tuple[float, float, float, float]: 
+    def bbox(self) -> Tuple[float, float, float, float]:
         """Return level extent, based on tile limits
 
         Returns:
             Tuple[float, float, float, float]: level terrain extent (xmin, ymin, xmax, ymax)
-        """        
+        """
         min_bbox = self.__pyramid.tms.get_level(self.__id).tile_to_bbox(self.__tile_limits["min_col"], self.__tile_limits["max_row"])
         print(min_bbox)
         max_bbox = self.__pyramid.tms.get_level(self.__id).tile_to_bbox(self.__tile_limits["max_col"], self.__tile_limits["min_row"])
@@ -293,19 +293,19 @@ def bbox(self) -> Tuple[float, float, float, float]:
         return (min_bbox[0], min_bbox[1], max_bbox[2], max_bbox[3])
 
     @property
-    def resolution(self) -> str: 
+    def resolution(self) -> str:
         return self.__pyramid.tms.get_level(self.__id).resolution
 
     @property
-    def tile_matrix(self) -> TileMatrix: 
+    def tile_matrix(self) -> TileMatrix:
         return self.__pyramid.tms.get_level(self.__id)
 
     @property
-    def slab_width(self) -> int: 
+    def slab_width(self) -> int:
         return self.__slab_size[0]
 
     @property
-    def slab_height(self) -> int: 
+    def slab_height(self) -> int:
         return self.__slab_size[1]
 
     def is_in_limits(self, column: int, row: int) -> bool:
@@ -327,7 +327,7 @@ def set_limits_from_bbox(self, bbox: Tuple[float, float, float, float]) -> None:
             bbox (Tuple[float, float, float, float]): terrain extent (xmin, ymin, xmax, ymax), in TMS coordinates system
 
         """
-        
+
         col_min, row_min, col_max, row_max = self.__pyramid.tms.get_level(self.__id).bbox_to_tiles(bbox)
         self.__tile_limits = {
             "min_row": row_min,
@@ -350,9 +350,9 @@ class Pyramid:
         __format (str): Data format
         __storage (Dict[str, Union[rok4.Storage.StorageType,str,int]]): Pyramid's storage informations (type, root and depth if FILE storage)
         __raster_specifications (Dict): If raster pyramid, raster specifications
-        __content (Dict): Loading status (loaded) and list content (cache). 
+        __content (Dict): Loading status (loaded) and list content (cache).
 
-            Example (S3 storage): 
+            Example (S3 storage):
 
                 {
                     'cache': {
@@ -394,7 +394,7 @@ def from_descriptor(cls, descriptor: str) -> 'Pyramid':
 
         Returns:
             Pyramid: a Pyramid instance
-        """        
+        """
         try:
             data = json.loads(get_data_str(descriptor))
 
@@ -469,7 +469,7 @@ def from_other(cls, other: 'Pyramid', name: str, storage: Dict) -> 'Pyramid':
             pyramid = cls()
 
             # Attributs communs
-            pyramid.__name = name 
+            pyramid.__name = name
             pyramid.__storage = storage
             pyramid.__masks = other.__masks
 
@@ -511,12 +511,12 @@ def __str__(self) -> str:
         return f"{self.type.name} pyramid '{self.__name}' ({self.__storage['type'].name} storage)"
 
     @property
-    def serializable(self) -> Dict: 
+    def serializable(self) -> Dict:
         """Get the dict version of the pyramid object, descriptor compliant
 
         Returns:
             Dict: descriptor structured object description
-        """        
+        """
         serialization = {
             "tile_matrix_set": self.__tms.name,
             "format": self.__format
@@ -551,7 +551,7 @@ def name(self) -> str:
     @property
     def tms(self) -> TileMatrixSet:
         return self.__tms
-        
+
     @property
     def raster_specifications(self) -> Dict:
         """Get raster specifications for a RASTER pyramid
@@ -563,34 +563,34 @@ def raster_specifications(self) -> Dict:
                 "photometric": "rgb",
                 "interpolation": "bicubic"
             }
-        
+
         Returns:
             Dict: Raster specifications, None if VECTOR pyramid
-        """        
+        """
         return self.__raster_specifications
 
     @property
-    def storage_type(self) -> StorageType: 
+    def storage_type(self) -> StorageType:
         """Get the storage type
 
         Returns:
             StorageType: FILE, S3 or CEPH
-        """        
+        """
         return self.__storage["type"]
 
     @property
-    def storage_root(self) -> str: 
+    def storage_root(self) -> str:
         """Get the pyramid's storage root.
 
         If storage is S3, the used cluster is removed.
 
         Returns:
             str: Pyramid's storage root
-        """        
+        """
         return self.__storage["root"].split("@", 1)[0] # Suppression de l'éventuel hôte de spécification du cluster S3
 
     @property
-    def storage_depth(self) -> int: 
+    def storage_depth(self) -> int:
         return self.__storage.get("depth", None)
 
 
@@ -600,7 +600,7 @@ def storage_s3_cluster(self) -> str:
 
         Returns:
             str: the host if known, None if the default one have to be used or if storage is not S3
-        """        
+        """
         if self.__storage["type"] == StorageType.S3:
             try:
                 return self.__storage["root"].split("@")[1]
@@ -619,7 +619,7 @@ def storage_depth(self, d: int) -> None:
 
         Raises:
             Exception: the depth is not equal to the already known depth
-        """        
+        """
         if "depth" in self.__storage and self.__storage["depth"] != d:
             raise Exception(f"Pyramid {pyramid.__descriptor} owns levels with different path depths")
         self.__storage["depth"] = d
@@ -629,11 +629,11 @@ def own_masks(self) -> bool:
         return self.__masks
 
     @property
-    def format(self) -> str: 
+    def format(self) -> str:
         return self.__format
 
     @property
-    def tile_extension(self) -> str: 
+    def tile_extension(self) -> str:
         if self.__format in ["TIFF_RAW_UINT8", "TIFF_LZW_UINT8", "TIFF_ZIP_UINT8", "TIFF_PKB_UINT8", "TIFF_RAW_FLOAT32", "TIFF_LZW_FLOAT32", "TIFF_ZIP_FLOAT32", "TIFF_PKB_FLOAT32"]:
             return "tif"
         elif self.__format in ["TIFF_JPG_UINT8", "TIFF_JPG90_UINT8"]:
@@ -646,12 +646,12 @@ def tile_extension(self) -> str:
             raise Exception(f"Unknown pyramid's format ({self.__format}), cannot return the tile extension")
 
     @property
-    def bottom_level(self) -> 'Level': 
+    def bottom_level(self) -> 'Level':
         """Get the best resolution level in the pyramid
 
         Returns:
             Level: the bottom level
-        """   
+        """
         return sorted(self.__levels.values(), key=lambda l: l.resolution)[0]
 
     @property
@@ -660,7 +660,7 @@ def top_level(self) -> 'Level':
 
         Returns:
             Level: the top level
-        """        
+        """
         return sorted(self.__levels.values(), key=lambda l: l.resolution)[-1]
 
     @property
@@ -669,7 +669,7 @@ def type(self) -> PyramidType:
 
         Returns:
             PyramidType: RASTER or VECTOR
-        """        
+        """
         if self.__format == "TIFF_PBF_MVT":
             return PyramidType.VECTOR
         else:
@@ -679,7 +679,7 @@ def load_list(self) -> None:
         """Load list content and cache it
 
         If list is already loaded, nothing done
-        """        
+        """
         if self.__content["loaded"]:
             return
 
@@ -688,7 +688,7 @@ def load_list(self) -> None:
 
         self.__content["loaded"] = True
 
-    def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:    
+    def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
         """Get list content
 
         List is copied as temporary file, roots are read and informations about each slab is returned. If list is already loaded, we yield the cached content
@@ -713,7 +713,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
 
             Value example:
 
-                ( 
+                (
                     (<SlabType.DATA: 'DATA'>, '18', 5424, 7526),
                     {
                         'link': False,
@@ -723,7 +723,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
                     }
                 )
 
-        """        
+        """
         if self.__content["loaded"]:
             for slab, infos in self.__content["cache"].items():
                 yield slab, infos
@@ -743,7 +743,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
                 # Lecture des racines
                 for line in listin:
                     line = line.rstrip()
-                    
+
                     if line == "#":
                         break
 
@@ -789,7 +789,7 @@ def get_level(self, level_id: str) -> 'Level':
         Returns:
             The corresponding pyramid's level, None if not present
         """
-      
+
         return self.__levels.get(level_id, None)
 
 
@@ -832,7 +832,7 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
         """
 
         sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution)
-        
+
         levels = []
 
         begin = False
@@ -859,19 +859,19 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
                     break
                 else:
                     continue
-        
+
         if top_id is None:
             # Pas de niveau du haut fourni, on a été jusqu'en haut et c'est normal
             end = True
 
         if not begin or not end:
             raise Exception(f"Provided levels ids are not consistent to extract levels from the pyramid {self.name}")
-      
+
         return levels
 
     def write_descriptor(self) -> None:
         """Write the pyramid's descriptor to the final location (in the pyramid's storage root)
-        """        
+        """
         content = json.dumps(self.serializable)
         put_data_str(content, self.__descriptor)
 
@@ -897,7 +897,7 @@ def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
             S3 stored pyramid
 
                 from rok4.Pyramid import Pyramid
-                
+
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/pyramid.json")
                     slab_type, level, column, row = self.get_infos_from_slab_path("s3://bucket_name/path/to/pyramid/MASK_15_9164_5846")
@@ -907,7 +907,7 @@ def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
 
         Returns:
             Tuple[SlabType, str, int, int]: Slab's type (DATA or MASK), level identifier, slab's column and slab's row
-        """        
+        """
         if self.__storage["type"] == StorageType.FILE:
             parts = path.split("/")
 
@@ -953,17 +953,17 @@ def get_slab_path_from_infos(self, slab_type: SlabType, level: str, column: int,
 
         Returns:
             str: Absolute or relative slab's storage path
-        """        
+        """
         if self.__storage["type"] == StorageType.FILE:
             slab_path = os.path.join(slab_type.value, level, b36_path_encode(column, row, self.__storage["depth"]))
         else:
             slab_path = f"{slab_type.value}_{level}_{column}_{row}"
-        
+
         if full:
             return get_path_from_infos(self.__storage["type"], self.__storage["root"], self.__name, slab_path )
         else:
             return slab_path
-        
+
 
     def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         """Get a pyramid's tile as binary string
@@ -1014,7 +1014,7 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         """
 
         level_object = self.get_level(level)
-        
+
         if level_object is None:
             raise Exception(f"No level {level} in the pyramid")
 
@@ -1039,7 +1039,7 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         slab_path = self.get_slab_path_from_infos(SlabType.DATA, level, slab_column, slab_row)
 
         # Récupération des offset et tailles des tuiles dans la dalle
-        # Une dalle ROK4 a une en-tête fixe de 2048 octets, 
+        # Une dalle ROK4 a une en-tête fixe de 2048 octets,
         # puis sont stockés les offsets (chacun sur 4 octets)
         # puis les tailles (chacune sur 4 octets)
         try:
@@ -1122,12 +1122,12 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
 
 
         if self.__format == "TIFF_JPG_UINT8" or self.__format == "TIFF_JPG90_UINT8":
-            
+
             try:
                 img = Image.open(io.BytesIO(binary_tile))
             except Exception as e:
                 raise FormatError("JPEG", "binary tile", e)
-            
+
             data = numpy.asarray(img)
 
         elif self.__format == "TIFF_RAW_UINT8":
@@ -1135,14 +1135,14 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
                 binary_tile,
                 dtype = numpy.dtype('uint8')
             )
-            data.shape = (level_object.tile_matrix.tile_size[0], level_object.tile_matrix.tile_size[1], self.__raster_specifications["channels"]) 
+            data.shape = (level_object.tile_matrix.tile_size[0], level_object.tile_matrix.tile_size[1], self.__raster_specifications["channels"])
 
         elif self.__format == "TIFF_PNG_UINT8":
             try:
                 img = Image.open(io.BytesIO(binary_tile))
             except Exception as e:
                 raise FormatError("PNG", "binary tile", e)
-            
+
             data = numpy.asarray(img)
 
         elif self.__format == "TIFF_ZIP_UINT8":
@@ -1154,7 +1154,7 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
             except Exception as e:
                 raise FormatError("ZIP", "binary tile", e)
 
-            data.shape = (level_object.tile_matrix.tile_size[0], level_object.tile_matrix.tile_size[1], self.__raster_specifications["channels"]) 
+            data.shape = (level_object.tile_matrix.tile_size[0], level_object.tile_matrix.tile_size[1], self.__raster_specifications["channels"])
 
         elif self.__format == "TIFF_ZIP_FLOAT32":
             try:
@@ -1165,14 +1165,14 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
             except Exception as e:
                 raise FormatError("ZIP", "binary tile", e)
 
-            data.shape = (level_object.tile_matrix.tile_size[0], level_object.tile_matrix.tile_size[1], self.__raster_specifications["channels"]) 
+            data.shape = (level_object.tile_matrix.tile_size[0], level_object.tile_matrix.tile_size[1], self.__raster_specifications["channels"])
 
         elif self.__format == "TIFF_RAW_FLOAT32":
             data = numpy.frombuffer(
                 binary_tile,
                 dtype = numpy.dtype('float32')
             )
-            data.shape = (level_object.tile_matrix.tile_size[0], level_object.tile_matrix.tile_size[1], self.__raster_specifications["channels"]) 
+            data.shape = (level_object.tile_matrix.tile_size[0], level_object.tile_matrix.tile_size[1], self.__raster_specifications["channels"])
 
         else:
             raise NotImplementedError(f"Cannot get tile as raster data for format {self.__format}")
@@ -1281,7 +1281,7 @@ def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> T
         level_object = self.bottom_level
         if level is not None:
             level_object = self.get_level(level)
-        
+
         if level_object is None:
             raise Exception(f"Cannot found the level to calculate indices")
 
@@ -1290,3 +1290,29 @@ def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> T
             x, y = reproject_point((x, y), sr, self.__tms.sr )
 
         return (level_object.id,) + level_object.tile_matrix.point_to_indices(x, y)
+
+    @property
+    def size(self) -> int:
+        """Get the size of the pyramid
+
+        Args:
+            bottom_id (str): optionnal specific bottom level id. Defaults to None.
+            top_id (str): optionnal specific top level id. Defaults to None.
+
+        Examples:
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+                    levels = pyramid.size()
+
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and get his size")
+
+        Returns:
+            int: size of the pyramid
+        """
+        if not hasattr(self,"_Pyramid__size") :
+            self.__size = size_path(get_path_from_infos(self.__storage["type"], self.__storage["root"], self.__name))
+        return self.__size
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index dc19b80..fe785fc 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -65,7 +65,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',st
 
     Returns:
         Tuple[Dict[str, Union['boto3.client',str]], str, str]: the S3 informations (client, host, key, secret) and the simple bucket name
-    """    
+    """
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
 
     if not __S3_CLIENTS:
@@ -122,7 +122,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',st
 
 def disconnect_s3_clients() -> None:
     """Clean S3 clients
-    """    
+    """
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
     __S3_CLIENTS = dict()
     __S3_DEFAULT_CLIENT = None
@@ -143,7 +143,7 @@ def __get_ceph_ioctx(pool: str) -> 'rados.Ioctx':
 
     Returns:
         rados.Ioctx: IO ceph context
-    """    
+    """
     global __CEPH_CLIENT, __CEPH_IOCTXS
 
     if __CEPH_CLIENT is None:
@@ -155,7 +155,7 @@ def __get_ceph_ioctx(pool: str) -> 'rados.Ioctx':
             )
 
             __CEPH_CLIENT.connect()
-            
+
         except KeyError as e:
             raise MissingEnvironmentError(e)
         except Exception as e:
@@ -166,12 +166,12 @@ def __get_ceph_ioctx(pool: str) -> 'rados.Ioctx':
             __CEPH_IOCTXS[pool] = __CEPH_CLIENT.open_ioctx(pool)
         except Exception as e:
             raise StorageError("CEPH", e)
-    
+
     return __CEPH_IOCTXS[pool]
 
 def disconnect_ceph_clients() -> None:
     """Clean CEPH clients
-    """    
+    """
     global __CEPH_CLIENT, __CEPH_IOCTXS
     __CEPH_CLIENT = None
     __CEPH_IOCTXS = dict()
@@ -182,8 +182,8 @@ def get_infos_from_path(path: str) -> Tuple[StorageType, str, str, str]:
     """Extract storage type, the unprefixed path, the container and the basename from path (Default: FILE storage)
 
     For a FILE storage, the tray is the directory and the basename is the file name.
-    
-    For an object storage (CEPH or S3), the tray is the bucket or the pool and the basename is the object name. 
+
+    For an object storage (CEPH or S3), the tray is the bucket or the pool and the basename is the object name.
     For a S3 bucket, format can be <bucket name>@<cluster name> to use several clusters. Cluster name is the host (without protocol)
 
     Args:
@@ -215,7 +215,7 @@ def get_path_from_infos(storage_type: StorageType, *args) -> str:
 
     Returns:
         str: Full path
-    """    
+    """
     return f"{storage_type.value}{os.path.join(*args)}"
 
 
@@ -257,7 +257,7 @@ def get_data_str(path: str) -> str:
     return get_data_binary(path).decode('utf-8')
 
 
-def get_data_binary(path: str, range: Tuple[int, int] = None) -> str: 
+def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
     """Load data into a binary string
 
     Args:
@@ -273,10 +273,10 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
         str: Data binary content
     """
 
-    storage_type, path, tray_name, base_name  = get_infos_from_path(path)        
+    storage_type, path, tray_name, base_name  = get_infos_from_path(path)
 
     if storage_type == StorageType.S3:
-        
+
         s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
@@ -302,7 +302,7 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             raise StorageError("S3", e)
 
     elif storage_type == StorageType.CEPH:
-        
+
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -327,7 +327,7 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             else:
                 f.seek(range[0])
                 data = f.read(range[1])
-            
+
             f.close()
 
         except FileNotFoundError as e:
@@ -358,7 +358,7 @@ def put_data_str(data: str, path: str) -> None:
     storage_type, path, tray_name, base_name  = get_infos_from_path(path)
 
     if storage_type == StorageType.S3:
-        
+
         s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
@@ -371,7 +371,7 @@ def put_data_str(data: str, path: str) -> None:
             raise StorageError("S3", e)
 
     elif storage_type == StorageType.CEPH:
-        
+
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -553,7 +553,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
     # Réalisation de la copie, selon les types de stockage
     if from_type == StorageType.FILE and to_type == StorageType.FILE :
-        
+
         try:
             if to_tray != "":
                 os.makedirs(to_tray, exist_ok=True)
@@ -569,13 +569,13 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             raise StorageError(f"FILE", f"Cannot copy file {from_path} to {to_path} : {e}")
 
     elif from_type == StorageType.S3 and to_type == StorageType.FILE :
-        
+
         s3_client, from_bucket = __get_s3_client(from_tray)
 
         try:
             if to_tray != "":
                 os.makedirs(to_tray, exist_ok=True)
-            
+
             s3_client["client"].download_file(from_bucket, from_base_name, to_path)
 
             if from_md5 is not None :
@@ -589,7 +589,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
     elif from_type == StorageType.FILE and to_type == StorageType.S3 :
 
         s3_client, to_bucket = __get_s3_client(to_tray)
-        
+
         try:
             s3_client["client"].upload_file(from_path, to_bucket, to_base_name)
 
@@ -611,7 +611,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                     {
                         'Bucket': from_bucket,
                         'Key': from_base_name
-                    }, 
+                    },
                     to_bucket, to_base_name
                 )
             else:
@@ -626,7 +626,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
         except Exception as e:
             raise StorageError(f"S3", f"Cannot copy S3 object {from_path} to {to_path} : {e}")
-        
+
 
     elif from_type == StorageType.CEPH and to_type == StorageType.FILE :
 
@@ -668,7 +668,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
     elif from_type == StorageType.FILE and to_type == StorageType.CEPH :
 
         ioctx = __get_ceph_ioctx(to_tray)
-        
+
         if from_md5 is not None:
             checker = hashlib.md5()
 
@@ -730,7 +730,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
         except Exception as e:
             raise StorageError(f"CEPH", f"Cannot copy CEPH object {from_path} to {to_path} : {e}")
-            
+
     elif from_type == StorageType.CEPH and to_type == StorageType.S3 :
 
         from_ioctx = __get_ceph_ioctx(from_tray)
@@ -814,7 +814,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
             raise StorageError("S3", e)
 
     elif target_type == StorageType.CEPH:
-        
+
         ioctx = __get_ceph_ioctx(link_tray)
 
         try:
@@ -850,7 +850,7 @@ def get_osgeo_path(path: str) -> str:
 
     Returns:
         str: GDAL/OGR Open compliant path
-    """    
+    """
 
     storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
 
@@ -871,3 +871,84 @@ def get_osgeo_path(path: str) -> str:
 
     else:
         raise NotImplementedError(f"Cannot get a GDAL/OGR compliant path from {path}")
+
+def size_path(path: str) -> int :
+    """Return the size of the path given (or, for the CEPH, the sum of the size of each object of the .list)
+
+    Args:
+        path (str): Source path
+
+    Raises:
+        StorageError: Unhandled link or link issue
+        MissingEnvironmentError: Missing object storage informations
+
+    Returns:
+        int: size of the path
+    """
+    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
+
+    if storage_type == StorageType.FILE:
+        try :
+            total = 0
+            with os.scandir(unprefixed_path) as it:
+                for entry in it:
+                    if entry.is_file():
+                        total += entry.stat().st_size
+                    elif entry.is_dir():
+                        total += size_path(entry.path)
+
+        except Exception as e:
+            raise StorageError("FILE", e)
+
+    elif storage_type == StorageType.S3:
+        s3_client, bucket_name = __get_s3_client(tray_name)
+
+        try :
+            paginator = s3_client["client"].get_paginator('list_objects_v2')
+            pages = paginator.paginate(
+                Bucket=bucket_name,
+                Prefix=base_name+"/",
+                PaginationConfig={
+                    'PageSize': 10000,
+                }
+            )
+            total = 0
+            for page in pages:
+                for key in page['Contents']:
+                    total += key['Size']
+
+        except Exception as e:
+            raise StorageError("S3", e)
+
+
+    elif storage_type == StorageType.CEPH:
+        ioctx = __get_ceph_ioctx(tray_name)
+
+        try :
+            list_obj = tempfile.NamedTemporaryFile(mode='r', delete=False)
+            list_file = list_obj.name
+            copy(path+".list", f"file://{list_file}")
+
+            with open(list_file,"r") as f :
+                objets = f.readlines()
+
+            os.remove(list_file)
+
+            total = 0
+            if "=" in objets[0] :
+                pool = objets[0].split("=")[1].split("\n")[0]
+                ioctx = __get_ceph_ioctx(pool)
+
+                for i in range (2, len(objets)) :
+                    total += ioctx.stat(objets[i].split("/")[1].split("\n")[0])[0]
+
+            else :
+                for i in range (len(objets)) :
+                    total += ioctx.stat(objets[i].split("/")[1].split("\n")[0])[0]
+
+        except Exception as e:
+            raise StorageError("CEPH", e)
+    else:
+        raise StorageError("UNKNOWN", "Unhandled storage type to calculate size")
+
+    return total
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 34a5c37..9029895 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -20,7 +20,7 @@ def test_hash_file_ok(mock_file):
     except Exception as exc:
         assert False, f"FILE md5 sum raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {}, clear=True)  
+@mock.patch.dict(os.environ, {}, clear=True)
 def test_get_infos_from_path():
     assert (StorageType.S3, "toto/titi", "toto", "titi") == get_infos_from_path("s3://toto/titi")
     assert (StorageType.FILE, "/toto/titi/tutu.json", "/toto/titi", "tutu.json") == get_infos_from_path("file:///toto/titi/tutu.json")
@@ -28,7 +28,7 @@ def test_get_infos_from_path():
     assert (StorageType.FILE, "wrong://toto/titi", "wrong://toto", "titi") == get_infos_from_path("wrong://toto/titi")
 
 
-@mock.patch.dict(os.environ, {}, clear=True)  
+@mock.patch.dict(os.environ, {}, clear=True)
 def test_get_path_from_infos():
     assert get_path_from_infos(StorageType.S3, "toto", "toto/titi") == "s3://toto/toto/titi"
     assert get_path_from_infos(StorageType.FILE, "/toto/titi", "tutu.json") == "file:///toto/titi/tutu.json"
@@ -66,7 +66,7 @@ def test_s3_invalid_endpoint(mocked_s3_client):
 def test_file_read_error(mock_file):
     with pytest.raises(FileNotFoundError):
         data = get_data_str("file:///path/to/file.ext")
-    
+
     mock_file.assert_called_with("/path/to/file.ext", "rb")
 
 
@@ -80,7 +80,7 @@ def test_file_read_ok(mock_file):
     except Exception as exc:
         assert False, f"FILE read raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_s3_read_nok(mocked_s3_client):
     disconnect_s3_clients()
@@ -90,7 +90,7 @@ def test_s3_read_nok(mocked_s3_client):
     with pytest.raises(StorageError):
         data = get_data_str("s3://bucket/path/to/object")
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_s3_read_ok(mocked_s3_client):
 
@@ -110,7 +110,7 @@ def test_s3_read_ok(mocked_s3_client):
         assert False, f"S3 read raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 def test_ceph_read_ok(mocked_rados_client):
 
@@ -131,7 +131,7 @@ def test_ceph_read_ok(mocked_rados_client):
 
 ############ put_data_str
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_s3_write_nok(mocked_s3_client):
 
@@ -144,7 +144,7 @@ def test_s3_write_nok(mocked_s3_client):
         put_data_str("data", "s3://bucket/path/to/object")
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_s3_write_ok(mocked_s3_client):
 
@@ -158,7 +158,7 @@ def test_s3_write_ok(mocked_s3_client):
         assert False, f"S3 write raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 def test_ceph_write_ok(mocked_rados_client):
 
@@ -190,7 +190,7 @@ def test_copy_file_file_ok(mock_hash_file, mock_copyfile, mock_makedirs):
         assert False, f"FILE -> FILE copy raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 @mock.patch('os.makedirs', return_value=None)
 @mock.patch('rok4.Storage.hash_file', return_value="toto")
@@ -210,7 +210,7 @@ def test_copy_s3_file_ok(mock_hash_file, mock_makedirs, mocked_s3_client):
         assert False, f"S3 -> FILE copy raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 @mock.patch('os.makedirs', return_value=None)
 @mock.patch('rok4.Storage.hash_file', return_value="toto")
@@ -226,7 +226,7 @@ def test_copy_s3_file_nok(mock_hash_file, mock_makedirs, mocked_s3_client):
         mock_makedirs.assert_called_once_with("/path/to", exist_ok=True)
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_copy_file_s3_ok(mocked_s3_client):
 
@@ -242,7 +242,7 @@ def test_copy_file_s3_ok(mocked_s3_client):
         assert False, f"FILE -> S3 copy raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_copy_s3_s3_ok(mocked_s3_client):
 
@@ -258,7 +258,7 @@ def test_copy_s3_s3_ok(mocked_s3_client):
         assert False, f"S3 -> S3 copy raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_copy_s3_s3_intercluster_ok(mocked_s3_client):
 
@@ -274,7 +274,7 @@ def test_copy_s3_s3_intercluster_ok(mocked_s3_client):
         assert False, f"S3 -> S3 inter cluster copy raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_copy_s3_s3_intercluster_nok(mocked_s3_client):
 
@@ -287,7 +287,7 @@ def test_copy_s3_s3_intercluster_nok(mocked_s3_client):
     with pytest.raises(StorageError):
         copy("s3://bucket@a/source.ext", "s3://bucket@c/destination.ext", "toto")
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 @mock.patch('os.makedirs', return_value=None)
 @patch("builtins.open", new_callable=mock_open)
@@ -306,7 +306,7 @@ def test_copy_ceph_file_ok(mock_file, mock_makedirs, mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH -> FILE copy raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 @patch("builtins.open", new_callable=mock_open, read_data=b"data")
 def test_copy_file_ceph_ok(mock_file, mocked_rados_client):
@@ -323,7 +323,7 @@ def test_copy_file_ceph_ok(mock_file, mocked_rados_client):
     except Exception as exc:
         assert False, f"FILE -> CEPH copy raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 @patch("builtins.open", new_callable=mock_open, read_data=b"data")
 def test_copy_ceph_ceph_ok(mock_file, mocked_rados_client):
@@ -342,7 +342,7 @@ def test_copy_ceph_ceph_ok(mock_file, mocked_rados_client):
         assert False, f"CEPH -> CEPH copy raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c", "ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c", "ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 @mock.patch('rok4.Storage.boto3.client')
 @patch("builtins.open", new_callable=mock_open, read_data=b"data")
@@ -379,7 +379,7 @@ def test_link_hard_nok():
     with pytest.raises(StorageError):
         link("ceph://pool1/source.ext", "ceph://pool2/destination.ext", True)
 
-@mock.patch.dict(os.environ, {}, clear=True)  
+@mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch('os.symlink', return_value=None)
 def test_link_file_ok(mock_link):
     try:
@@ -389,7 +389,7 @@ def test_link_file_ok(mock_link):
         assert False, f"FILE link raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {}, clear=True)  
+@mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch('os.link', return_value=None)
 def test_hlink_file_ok(mock_link):
     try:
@@ -398,7 +398,7 @@ def test_hlink_file_ok(mock_link):
     except Exception as exc:
         assert False, f"FILE hard link raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 def test_link_ceph_ok(mocked_rados_client):
 
@@ -415,7 +415,7 @@ def test_link_ceph_ok(mocked_rados_client):
         assert False, f"CEPH link raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_link_s3_ok(mocked_s3_client):
 
@@ -430,7 +430,7 @@ def test_link_s3_ok(mocked_s3_client):
         assert False, f"S3 link raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_link_s3_nok(mocked_s3_client):
 
@@ -444,7 +444,7 @@ def test_link_s3_nok(mocked_s3_client):
 
 ############ get_size
 
-@mock.patch.dict(os.environ, {}, clear=True)  
+@mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch('os.stat')
 def test_size_file_ok(mock_stat):
     mock_stat.return_value.st_size = 12
@@ -454,7 +454,7 @@ def test_size_file_ok(mock_stat):
     except Exception as exc:
         assert False, f"FILE size raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 def test_size_ceph_ok(mocked_rados_client):
 
@@ -472,7 +472,7 @@ def test_size_ceph_ok(mocked_rados_client):
         assert False, f"CEPH size raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_size_s3_ok(mocked_s3_client):
 
@@ -490,7 +490,7 @@ def test_size_s3_ok(mocked_s3_client):
 
 ############ exists
 
-@mock.patch.dict(os.environ, {}, clear=True)  
+@mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch('os.path.exists', return_value=True)
 def test_exists_file_ok(mock_exists):
     try:
@@ -504,7 +504,7 @@ def test_exists_file_ok(mock_exists):
     except Exception as exc:
         assert False, f"FILE not exists raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 def test_exists_ceph_ok(mocked_rados_client):
 
@@ -527,7 +527,7 @@ def test_exists_ceph_ok(mocked_rados_client):
         assert False, f"CEPH not exists raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_exists_s3_ok(mocked_s3_client):
 
@@ -550,7 +550,7 @@ def test_exists_s3_ok(mocked_s3_client):
 
 ############ remove
 
-@mock.patch.dict(os.environ, {}, clear=True)  
+@mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch('os.remove')
 def test_remove_file_ok(mock_remove):
     mock_remove.return_value = None
@@ -565,7 +565,7 @@ def test_remove_file_ok(mock_remove):
     except Exception as exc:
         assert False, f"FILE deletion (not found) raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 @mock.patch('rok4.Storage.rados.Rados')
 def test_remove_ceph_ok(mocked_rados_client):
 
@@ -588,7 +588,7 @@ def test_remove_ceph_ok(mocked_rados_client):
         assert False, f"CEPH deletion (not found) raises an exception: {exc}"
 
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)  
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')
 def test_remove_s3_ok(mocked_s3_client):
 
@@ -613,11 +613,11 @@ def test_get_osgeo_path_file_ok():
     except Exception as exc:
         assert False, f"FILE osgeo path raises an exception: {exc}"
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True) 
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 def test_get_osgeo_path_s3_ok():
 
     disconnect_s3_clients()
-    
+
     try:
         path = get_osgeo_path("s3://bucket@b/to/object.ext")
         assert path == "/vsis3/bucket/to/object.ext"
@@ -628,4 +628,70 @@ def test_get_osgeo_path_s3_ok():
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_get_osgeo_path_nok():
     with pytest.raises(NotImplementedError):
-        get_osgeo_path("ceph://pool/data.ext")
\ No newline at end of file
+        get_osgeo_path("ceph://pool/data.ext")
+
+############ size_path
+def test_size_path_file_ok():
+    try:
+        size = size_path("file://tests/fixtures/TIFF_PBF_MVT")
+        assert size == 124838
+    except Exception as exc:
+        assert False, f"FILE size of the path raises an exception: {exc}"
+
+def test_size_file_nok():
+    with pytest.raises(StorageError) :
+        size = size_path("file://tests/fixtures/TIFF_PBF_M")
+
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
+@mock.patch('rok4.Storage.rados.Rados')
+def test_size_path_ceph_ok(mocked_rados_client):
+
+    disconnect_ceph_clients()
+    ioctx_instance = MagicMock()
+    ioctx_instance.read.return_value = b"0=TIFF_PBF_MVT\n#\n0/21.tif\n0/22.tif"
+    ioctx_instance.stat.return_value = (100,5)
+    ceph_instance = MagicMock()
+    ceph_instance.open_ioctx.return_value = ioctx_instance
+    mocked_rados_client.return_value = ceph_instance
+
+    try:
+        size = size_path("ceph://pool/path")
+        assert size == 200
+    except Exception as exc:
+        assert False, f"CEPH size of the path raises an exception: {exc}"
+
+@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
+@mock.patch('rok4.Storage.rados.Rados')
+def test_size_path_ceph_ok2(mocked_rados_client):
+
+    disconnect_ceph_clients()
+    ioctx_instance = MagicMock()
+    ioctx_instance.read.return_value = b"0/21.tif\n0/22.tif"
+    ioctx_instance.stat.return_value = (100,5)
+    ceph_instance = MagicMock()
+    ceph_instance.open_ioctx.return_value = ioctx_instance
+    mocked_rados_client.return_value = ceph_instance
+
+    try:
+        size = size_path("ceph://pool/path")
+        assert size == 200
+    except Exception as exc:
+        assert False, f"CEPH size of the path raises an exception: {exc}"
+
+@mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
+@mock.patch('rok4.Storage.boto3.client')
+def test_size_path_s3_ok(mocked_s3_client):
+
+    disconnect_s3_clients()
+    pages = [{"Contents" : [{"Size" : 10},{"Size" : 20}]}, {"Contents" : [{"Size" : 50}]}]
+    paginator = MagicMock()
+    paginator.paginate.return_value = pages
+    client = MagicMock()
+    client.get_paginator.return_value = paginator
+    mocked_s3_client.return_value = client
+
+    try:
+        size = size_path("s3://bucket/path")
+        assert size == 80
+    except Exception as exc:
+        assert False, f"S3 size of the path raises an exception: {exc}"

From 3b4f221c5cfb87415a9f74d270cbd7064dcb4cde Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Thu, 20 Apr 2023 10:20:48 +0200
Subject: [PATCH 2/3] =?UTF-8?q?Erreur=20de=20copier-coller=20corrig=C3=A9?=
 =?UTF-8?q?=20dans=20la=20documentation?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Pyramid.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 2f5aa9f..e2ebb8d 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -1295,17 +1295,13 @@ def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> T
     def size(self) -> int:
         """Get the size of the pyramid
 
-        Args:
-            bottom_id (str): optionnal specific bottom level id. Defaults to None.
-            top_id (str): optionnal specific top level id. Defaults to None.
-
         Examples:
 
                 from rok4.Pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
-                    levels = pyramid.size()
+                    size = pyramid.size()
 
                 except Exception as e:
                     print("Cannot load the pyramid from its descriptor and get his size")

From 68ff30d66fea658ffc714870534501e2d3af80a1 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Mon, 12 Jun 2023 16:30:12 +0200
Subject: [PATCH 3/3] Paasage du size_path du Ceph en NotImplementedError

---
 src/rok4/Storage.py   | 27 +--------------------------
 tests/test_Storage.py | 34 ++--------------------------------
 2 files changed, 3 insertions(+), 58 deletions(-)

diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index fe785fc..1a41a62 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -922,32 +922,7 @@ def size_path(path: str) -> int :
 
 
     elif storage_type == StorageType.CEPH:
-        ioctx = __get_ceph_ioctx(tray_name)
-
-        try :
-            list_obj = tempfile.NamedTemporaryFile(mode='r', delete=False)
-            list_file = list_obj.name
-            copy(path+".list", f"file://{list_file}")
-
-            with open(list_file,"r") as f :
-                objets = f.readlines()
-
-            os.remove(list_file)
-
-            total = 0
-            if "=" in objets[0] :
-                pool = objets[0].split("=")[1].split("\n")[0]
-                ioctx = __get_ceph_ioctx(pool)
-
-                for i in range (2, len(objets)) :
-                    total += ioctx.stat(objets[i].split("/")[1].split("\n")[0])[0]
-
-            else :
-                for i in range (len(objets)) :
-                    total += ioctx.stat(objets[i].split("/")[1].split("\n")[0])[0]
-
-        except Exception as e:
-            raise StorageError("CEPH", e)
+        raise NotImplementedError
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to calculate size")
 
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 9029895..f4b9757 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -643,40 +643,10 @@ def test_size_file_nok():
         size = size_path("file://tests/fixtures/TIFF_PBF_M")
 
 @mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
-@mock.patch('rok4.Storage.rados.Rados')
-def test_size_path_ceph_ok(mocked_rados_client):
-
-    disconnect_ceph_clients()
-    ioctx_instance = MagicMock()
-    ioctx_instance.read.return_value = b"0=TIFF_PBF_MVT\n#\n0/21.tif\n0/22.tif"
-    ioctx_instance.stat.return_value = (100,5)
-    ceph_instance = MagicMock()
-    ceph_instance.open_ioctx.return_value = ioctx_instance
-    mocked_rados_client.return_value = ceph_instance
-
-    try:
-        size = size_path("ceph://pool/path")
-        assert size == 200
-    except Exception as exc:
-        assert False, f"CEPH size of the path raises an exception: {exc}"
+def test_size_path_ceph_nok():
 
-@mock.patch.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
-@mock.patch('rok4.Storage.rados.Rados')
-def test_size_path_ceph_ok2(mocked_rados_client):
-
-    disconnect_ceph_clients()
-    ioctx_instance = MagicMock()
-    ioctx_instance.read.return_value = b"0/21.tif\n0/22.tif"
-    ioctx_instance.stat.return_value = (100,5)
-    ceph_instance = MagicMock()
-    ceph_instance.open_ioctx.return_value = ioctx_instance
-    mocked_rados_client.return_value = ceph_instance
-
-    try:
+    with pytest.raises(NotImplementedError):
         size = size_path("ceph://pool/path")
-        assert size == 200
-    except Exception as exc:
-        assert False, f"CEPH size of the path raises an exception: {exc}"
 
 @mock.patch.dict(os.environ, {"ROK4_S3_URL": "https://a,https://b", "ROK4_S3_SECRETKEY": "a,b", "ROK4_S3_KEY": "a,b"}, clear=True)
 @mock.patch('rok4.Storage.boto3.client')