From d81e8bf38b6c1dd3ed49516f490c7fc3f1b7a516 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <xavier.dumetz@ign.fr>
Date: Wed, 18 Jan 2023 15:36:45 +0100
Subject: [PATCH 01/89] =?UTF-8?q?Initialisation=20des=20d=C3=A9veloppement?=
 =?UTF-8?q?s=20sur=20la=20librairie=20Raster.py?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |  6 ++++++
 README.md            | 12 ++++++------
 rok4/Raster.py       |  7 +++++++
 tests/test_Raster.py |  7 +++++++
 4 files changed, 26 insertions(+), 6 deletions(-)
 create mode 100644 rok4/Raster.py
 create mode 100644 tests/test_Raster.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9559b5..8abc4c8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,12 @@ Prise en charge de plusieurs clusters S3 de stockage.
 
 * Librairie d'abstraction du stockage :
   * Prise en charge de plusieurs clusters S3. Les variables d'environnement pour le stockage S3 précisent plusieurs valeurs séparées par des virgules, et les noms des buckets peuvent être suffixés par "@{S3 cluster host}". Par défaut, le premier cluster défini est utilisé. L'hôte du cluster n'est jamais écrit dans le descripteur de pyramide ou le fichier liste (puisque stockés sur le cluster, on sait sur lequel sont les objets). Les objets symboliques ne le précisent pas non plus et ne peuvent être qu'au sein d'un cluster S3
+* Librairie de lecture de données raster :
+  * Squelette minimal avec test unitaire d'invocation du constructeur
+
+### [Changed]
+
+* Appels explicites à python3 dans le README, pour tenir compte des distributions où l'exécutable `python` correspond par défaut à Python 2.7.
 
 <!-- 
 ### [Added]
diff --git a/README.md b/README.md
index 68d3853..f6f21a7 100644
--- a/README.md
+++ b/README.md
@@ -4,20 +4,20 @@ Ces librairies Python sont utilisées par les outils python du dépôt [pytools]
 
 ## Compiler la librairie
 
-`VERSION=1.0.0 python setup.py bdist_wheel`
+`VERSION=1.0.0 python3 setup.py bdist_wheel`
 
 ## Installer la librairie
 
 ```sh
-apt install python3-rados
-python -m venv --system-site-packages venv
+apt install python3-rados python3-venv python3-pytest
+python3 -m venv --system-site-packages venv
 source venv/bin/activate
-pip install rok4lib-1.0.0-py3-none-any.whl
+python3 -m pip install dist/rok4lib-1.0.0-py3-none-any.whl
 ```
 
 ## Jouer les tests unitaires
 
-`pytest`
+`python3 -m pytest`
 
 ## Utiliser la librairie
 
@@ -34,6 +34,6 @@ except Exception as exc:
 
 ```bash
 source venv/bin/activate
-pip install pdoc3 
+python3 -m pip install pdoc3 
 VERSION=1.0.0 pdoc --html rok4
 ```
\ No newline at end of file
diff --git a/rok4/Raster.py b/rok4/Raster.py
new file mode 100644
index 0000000..2b32334
--- /dev/null
+++ b/rok4/Raster.py
@@ -0,0 +1,7 @@
+"""Provide functions to describe a raster image
+
+The Raster class provides read-only access to information about a given raster file or object.
+"""
+
+class Raster():
+    trash_variable = None;
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
new file mode 100644
index 0000000..9f1b1c4
--- /dev/null
+++ b/tests/test_Raster.py
@@ -0,0 +1,7 @@
+from rok4.Raster import Raster
+
+import pytest
+
+def test_empty_constructor():
+    raster_object = Raster()
+

From cff15887e358e26b23d9eecd6ff9925b04d217c0 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <xavier.dumetz@ign.fr>
Date: Mon, 23 Jan 2023 17:20:53 +0100
Subject: [PATCH 02/89] =?UTF-8?q?WIP:=20impl=C3=A9mentation=20du=20constru?=
 =?UTF-8?q?cteur=20de=20la=20classe=20Raster.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |  2 +-
 rok4/Raster.py       | 36 +++++++++++++++++++++++++++++++++---
 tests/test_Raster.py | 17 ++++++++++++++++-
 3 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8abc4c8..6e4543e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,7 +11,7 @@ Prise en charge de plusieurs clusters S3 de stockage.
 * Librairie d'abstraction du stockage :
   * Prise en charge de plusieurs clusters S3. Les variables d'environnement pour le stockage S3 précisent plusieurs valeurs séparées par des virgules, et les noms des buckets peuvent être suffixés par "@{S3 cluster host}". Par défaut, le premier cluster défini est utilisé. L'hôte du cluster n'est jamais écrit dans le descripteur de pyramide ou le fichier liste (puisque stockés sur le cluster, on sait sur lequel sont les objets). Les objets symboliques ne le précisent pas non plus et ne peuvent être qu'au sein d'un cluster S3
 * Librairie de lecture de données raster :
-  * Squelette minimal avec test unitaire d'invocation du constructeur
+  * Squelette minimal avec tests unitaires d'invocation du constructeur
 
 ### [Changed]
 
diff --git a/rok4/Raster.py b/rok4/Raster.py
index 2b32334..f443ff1 100644
--- a/rok4/Raster.py
+++ b/rok4/Raster.py
@@ -1,7 +1,37 @@
-"""Provide functions to describe a raster image
+"""Provide functions to read information on raster data from file path or object path
+
+The module contains the following class :
+
+    - 'Raster' - Structure describing raster data.
 
-The Raster class provides read-only access to information about a given raster file or object.
 """
 
+from osgeo import ogr
+
+# Enable GDAL/OGR exceptions
+ogr.UseExceptions()
+
+
 class Raster():
-    trash_variable = None;
+    """A structure describing raster data
+
+    Attributes :
+        path (str): path to the file/object
+        bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
+        samples (int): number of color channels
+        mask (str): path to the associated mask file or object, if any (same name, but ".msk" extension)
+    """
+
+    def __init__(self, path: str) -> None:
+        """Basic constructor method
+
+        Args:
+            path (str): path to the file/object
+
+        """
+
+        self.path = path
+        self.bbox = ""
+        self.samples = 3
+        self.mask = ""
+
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 9f1b1c4..5ae7e86 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -3,5 +3,20 @@
 import pytest
 
 def test_empty_constructor():
-    raster_object = Raster()
+    catched_error = False
+    try:
+        raster_object = Raster()
+    except TypeError as exc:
+        catched_error = True
+    finally:
+        assert catched_error
+
+def test_nominal_constructor():
+    path = "file:///tmp/image.jpg"
+    raster_object = Raster(path)
+    assert raster_object.path == path
+    assert raster_object.bbox is not None
+    assert raster_object.samples is not None
+    assert raster_object.mask is not None
+
 

From e71ae56486b7809d7ff121075ba2d37d62c88c8e Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Tue, 24 Jan 2023 17:06:34 +0100
Subject: [PATCH 03/89] =?UTF-8?q?Impl=C3=A9mentation=20du=20constructeur?=
 =?UTF-8?q?=20rok4.Raster.Raster()=20Le=20constructeur=20fait=20pour=20le?=
 =?UTF-8?q?=20moment=20appel=20=C3=A0=20des=20fonctions=20non=20impl=C3=A9?=
 =?UTF-8?q?ment=C3=A9es=20pour=20calculer=20la=20BBox=20et=20le=20nombre?=
 =?UTF-8?q?=20de=20canaux=20de=20l'image.=20les=20attributs=20'path'=20at?=
 =?UTF-8?q?=20'mask'=20sont=20remplis=20apr=C3=A8s=20diff=C3=A9rentes=20v?=
 =?UTF-8?q?=C3=A9rifications=20sur=20les=20objets=20ou=20fichiers=20d'imag?=
 =?UTF-8?q?e=20et=20de=20masque=20associ=C3=A9.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |   3 +-
 rok4/Raster.py       |  67 ++++++++-
 tests/test_Raster.py | 331 ++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 377 insertions(+), 24 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef688f9..c74954a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,7 +12,8 @@ Prise en charge de plusieurs clusters S3 de stockage.
   * Chargement de données vecteur pour des fichiers shapefile, Geopackage, CSV et GeoJSON
   * Ecriture des tests unitaires
 * Librairie de lecture de données raster :
-  * Squelette minimal avec tests unitaires d'invocation du constructeur
+  * Constructeur implémenté
+    * Ce dernier fait appel à des fonctions internes qui ne sont pas encore implémentées.
 
 ### [Changed]
 
diff --git a/rok4/Raster.py b/rok4/Raster.py
index f443ff1..6bd510e 100644
--- a/rok4/Raster.py
+++ b/rok4/Raster.py
@@ -6,7 +6,12 @@
 
 """
 
-from osgeo import ogr
+import re
+import tempfile
+
+from osgeo import ogr, gdal
+
+from rok4.Storage import get_data_str, exists, get_infos_from_path, copy, StorageType
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
@@ -16,10 +21,10 @@ class Raster():
     """A structure describing raster data
 
     Attributes :
-        path (str): path to the file/object
+        path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
         bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
         samples (int): number of color channels
-        mask (str): path to the associated mask file or object, if any (same name, but ".msk" extension)
+        mask (str): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
     """
 
     def __init__(self, path: str) -> None:
@@ -28,10 +33,60 @@ def __init__(self, path: str) -> None:
         Args:
             path (str): path to the file/object
 
+        Raises:
+            RuntimeError: raised by OGR/GDAL if anything goes wrong
+            MissingEnvironmentError: Missing object storage informations
+            StorageError: Storage read issue
         """
 
+        if not exists(path):
+            raise Exception(f"No file or object found at path '{path}'.")
+
+        image_info = get_infos_from_path(path)
+
+        tmp_image_file = None
+        work_image_path = None
+        if image_info[0] == StorageType.FILE:
+            work_image_path = image_info[1]
+        else:
+            tmp_image_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
+            tmp_image_file.close()
+            work_image_path = tmp_image_file.name
+            copy(path, f"file://{work_image_path}")
+
+        image_datasource = gdal.Open(work_image_path)
         self.path = path
-        self.bbox = ""
-        self.samples = 3
-        self.mask = ""
+
+        path_pattern = re.compile('(/[^/]+?)\.[a-zA-Z0-9_-]+$')
+        mask_path = path_pattern.sub('\\1.msk', path)
+
+        tmp_mask_file = None
+        work_mask_path = None
+        if exists(mask_path):
+            if image_info[0] == StorageType.FILE:
+                work_mask_path = path_pattern.sub('\\1.msk', image_info[1])
+            else:
+                tmp_mask_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
+                tmp_mask_file.close()
+                work_mask_path = tmp_mask_file.name
+                copy(mask_path, f"file://{work_mask_path}") 
+            
+            ogr.GetDriverByName('GTiff').Open(work_mask_path)
+
+            self.mask = mask_path
+        else:
+            self.mask = None
+
+        self.bbox = _compute_bbox()
+        self.samples = _compute_samples()
+
+        tmp_image_file = None
+
+
+def _compute_bbox() -> tuple:
+    return None
+
+
+def _compute_samples() -> int:
+    return None
 
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 5ae7e86..4cc7c55 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,22 +1,319 @@
-from rok4.Raster import Raster
+"""Describes unit tests for the rok4.Raster module."""
+
+from rok4.Raster import *
+from rok4.Storage import StorageType
 
 import pytest
+from unittest.mock import *
+from unittest import mock, TestCase, skip
+
+class TestConstructorCommon(TestCase):
+    """Test class for the rok4.Raster.Raster(path) class constructor, for any storage type."""
+
+    def test_empty(self):
+        """Test case : Constructor called without the expected path argument."""
+
+        with pytest.raises(TypeError):
+            Raster()
+
+
+    @mock.patch('rok4.Raster.exists', return_value=False)
+    def test_image_not_found(self, mocked_exists):
+        """Test case : Constructor called on a path matching no file or object."""
+
+        path = "file:///home/user/image.tif"
+
+        with pytest.raises(Exception):
+            Raster(path)
+
+        mocked_exists.assert_called_once_with(path)
+
+
+
+class TestConstructorFile(TestCase):
+    """Test class for the rok4.Raster.Raster(path) class constructor, used with file storage."""
+
+    def setUp(self):
+        self.path = {
+            'protocol': 'file://',
+            'base_location': '/home/user',
+            'base_name': 'image',
+            'image': {},
+            'mask': {}
+        }
+        self.path['image']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.tif"
+        self.path['mask']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.msk"
+        self.path['image']['full'] = f"{self.path['protocol']}{self.path['image']['system']}"
+        self.path['mask']['full'] = f"{self.path['protocol']}{self.path['mask']['system']}"
+        
+        self.get_infos_from_path = (StorageType.FILE, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
+
+
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_samples', return_value=3)
+    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path):
+        """Test case : Constructor called nominally on an image without mask."""
+
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+
+        raster_object = Raster( self.path['image']['full'] )
+
+        mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
+        mocked_get_infos_from_path.assert_called_once_with( self.path['image']['full'] )
+        mocked_gdal_open.assert_called_once_with( self.path['image']['system'] )
+        assert raster_object.path == self.path['image']['full']
+        assert raster_object.mask is None
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
+
+        mocked_compute_samples.assert_called_once()
+        assert raster_object.samples == 3
+
+
+    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_samples', return_value=3)
+    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_get_driver):
+        """Test case : Constructor called nominally on an image with mask."""
+
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        # This next line emulates the return of ogr.GetDriverByName()
+        # TODO : manage to implent this using unittest.mock
+        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+
+        raster_object = Raster(self.path['image']['full'])
+
+        mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_get_driver.assert_called_once_with('GTiff')
+        mocked_gdal_open.assert_has_calls([ call(self.path['image']['system']), call(self.path['mask']['system']) ])
+        assert raster_object.path == self.path['image']['full']
+        assert raster_object.mask == self.path['mask']['full']
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
+
+        mocked_compute_samples.assert_called_once()
+        assert raster_object.samples == 3
+
+
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path):
+        """Test case : Constructor called on an unsupported 'image' file or object."""
+
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+
+        with pytest.raises(RuntimeError):
+            Raster(self.path['image']['full'])
+
+        mocked_exists.assert_called_once_with(self.path['image']['full'])
+        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
+
+
+    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=[None, RuntimeError])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_get_driver):
+        """Test case : Constructor called on an unsupported mask file or object."""
+
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        # This next line emulates the return of ogr.GetDriverByName()
+        # TODO : manage to implent this using unittest.mock
+        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+
+        with pytest.raises(RuntimeError):
+            Raster(self.path['image']['full'])      
+
+        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
+        mocked_get_driver.assert_called_once_with('GTiff')
+        mocked_gdal_open.assert_has_calls([ call(self.path['image']['system']), call(self.path['mask']['system']) ])
+
+
+
+class TestConstructorObject(TestCase):
+    """Test class for the rok4.Raster.Raster(path) class constructor, used with object storage."""
+
+    def setUp(self):
+        self.path = {
+            'protocol': 's3://',
+            'base_location': 'bucket',
+            'base_name': 'basename',
+            'image': {},
+            'mask': {}
+        }
+        self.path['image']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.tif"
+        self.path['mask']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.msk"
+        self.path['image']['full'] = f"{self.path['protocol']}{self.path['image']['system']}"
+        self.path['mask']['full'] = f"{self.path['protocol']}{self.path['mask']['system']}"
+
+        self.get_infos_from_path = (StorageType.S3, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
+
+        self.tmp_path = {
+            'image': {
+                'system': '/tmp/tempimage'
+            },
+            'mask': {
+                'system': '/tmp/tempmask'
+            },
+        }
+        self.tmp_path['image']['full'] = f"file://{self.tmp_path['image']['system']}"
+        self.tmp_path['mask']['full'] = f"file://{self.tmp_path['mask']['system']}"
+
+
+    @mock.patch('rok4.Raster.copy')
+    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_samples', return_value=3)
+    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
+        """Test case : Constructor called nominally on an image without mask."""
+        
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_tmp_file_close = Mock()
+        # This next line emulates the return of tempfile.NamedTemporaryFile()
+        # TODO : manage to implent this using unittest.mock
+        mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
+
+        raster_object = Raster(self.path['image']['full'])
+
+        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_create_temporary_file.assert_called_once_with(mode='r', delete=False)
+        mocked_copy.assert_called_once_with(self.path['image']['full'], self.tmp_path['image']['full'])
+        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
+        assert raster_object.path == self.path['image']['full']
+        assert raster_object.mask is None
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
+
+        mocked_compute_samples.assert_called_once()
+        assert raster_object.samples == 3
+
+
+    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.copy')
+    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_samples', return_value=3)
+    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_get_driver):
+        """Test case : Constructor called nominally on an image with mask."""
+        
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_tmp_file_close = Mock()
+        # This next instruction emulates the return of tempfile.NamedTemporaryFile()
+        # TODO : manage to implent this using unittest.mock
+        mocked_create_temporary_file.side_effect = [
+            type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
+            type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
+        ]
+        # This next line emulates the return of ogr.GetDriverByName()
+        # TODO : manage to implent this using unittest.mock
+        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+
+        raster_object = Raster(self.path['image']['full'])
+
+        expected_copy_calls = [
+            call(self.path['image']['full'], self.tmp_path['image']['full']),
+            call(self.path['mask']['full'], self.tmp_path['mask']['full'])
+        ]
+        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
+        mocked_copy.assert_has_calls(expected_copy_calls)
+        mocked_get_driver.assert_called_once_with('GTiff')
+        mocked_gdal_open.assert_has_calls([ call(self.tmp_path['image']['system']), call(self.tmp_path['mask']['system']) ])
+        assert raster_object.path == self.path['image']['full']
+        assert raster_object.mask == self.path['mask']['full']
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
+
+        mocked_compute_samples.assert_called_once()
+        assert raster_object.samples == 3
+
+    
+    @mock.patch('rok4.Raster.copy')
+    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
+        """Test case : Constructor called on an unsupported 'image' file or object."""
+        
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_tmp_file_close = Mock()
+        # This next line emulates the return of tempfile.NamedTemporaryFile()
+        # TODO : manage to implent this using unittest.mock
+        mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
+
+        with pytest.raises(RuntimeError):
+            Raster(self.path['image']['full'])
+
+        mocked_exists.assert_called_once_with(self.path['image']['full'])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_create_temporary_file.assert_called_once_with(mode='r', delete=False)
+        mocked_copy.assert_called_once_with(self.path['image']['full'], self.tmp_path['image']['full'])
+        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
+
+
+    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.copy')
+    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
+    @mock.patch('rok4.Raster.get_infos_from_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=[None, RuntimeError])
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_get_driver):
+        """Test case : Constructor called on an unsupported mask file or object."""
+        
+        mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_tmp_file_close = Mock()
+        # This next instruction emulates the return of tempfile.NamedTemporaryFile()
+        # TODO : manage to implent this using unittest.mock
+        mocked_create_temporary_file.side_effect = [
+            type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
+            type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
+        ]
+        # This next line emulates the return of ogr.GetDriverByName()
+        # TODO : manage to implent this using unittest.mock
+        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+
+        with pytest.raises(RuntimeError):
+            Raster(self.path['image']['full'])
+
+        expected_copy_calls = [
+            call(self.path['image']['full'], self.tmp_path['image']['full']),
+            call(self.path['mask']['full'], self.tmp_path['mask']['full'])
+        ]
+        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
+        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
+        mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
+        mocked_copy.assert_has_calls(expected_copy_calls)
+        mocked_get_driver.assert_called_once_with('GTiff')
+        mocked_gdal_open.assert_has_calls([ call(self.tmp_path['image']['system']), call(self.tmp_path['mask']['system']) ])
+
+
+
+class TestComputeBbox(TestCase):
+    """Test class for the rok4.Raster._compute_bbox function."""
+
 
-def test_empty_constructor():
-    catched_error = False
-    try:
-        raster_object = Raster()
-    except TypeError as exc:
-        catched_error = True
-    finally:
-        assert catched_error
-
-def test_nominal_constructor():
-    path = "file:///tmp/image.jpg"
-    raster_object = Raster(path)
-    assert raster_object.path == path
-    assert raster_object.bbox is not None
-    assert raster_object.samples is not None
-    assert raster_object.mask is not None
 
+class TestComputeSamples(TestCase):
+    """Test class for the rok4.Raster._compute_samples function."""
 

From a4120c562432cb7c11c0b407a65c7aabfbdd7d50 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Thu, 2 Mar 2023 14:13:31 +0100
Subject: [PATCH 04/89] =?UTF-8?q?Impl=C3=A9mentation=20dans=20la=20lib=20R?=
 =?UTF-8?q?aster=20du=20calcul=20de=20la=20boundingbox=20et=20de=20la=20d?=
 =?UTF-8?q?=C3=A9termination=20du=20nombre=20de=20canaux.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md            |   2 +-
 rok4/Raster.py       |  52 ++++++++++++---
 tests/test_Raster.py | 153 ++++++++++++++++++++++++++-----------------
 3 files changed, 137 insertions(+), 70 deletions(-)

diff --git a/README.md b/README.md
index 00a002e..cf017dd 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Ces librairies Python sont utilisées par les outils python du dépôt [pytools]
 
 ```sh
 apt install python3-rados python3-gdal python3-venv python3-pytest
-python -m venv --system-site-packages venv
+python3 -m venv --system-site-packages venv
 source venv/bin/activate
 python3 -m pip install dist/rok4lib-1.0.0-py3-none-any.whl
 ```
diff --git a/rok4/Raster.py b/rok4/Raster.py
index 6bd510e..1fbb56c 100644
--- a/rok4/Raster.py
+++ b/rok4/Raster.py
@@ -57,7 +57,7 @@ def __init__(self, path: str) -> None:
         image_datasource = gdal.Open(work_image_path)
         self.path = path
 
-        path_pattern = re.compile('(/[^/]+?)\.[a-zA-Z0-9_-]+$')
+        path_pattern = re.compile('(/[^/]+?)[.][a-zA-Z0-9_-]+$')
         mask_path = path_pattern.sub('\\1.msk', path)
 
         tmp_mask_file = None
@@ -69,24 +69,60 @@ def __init__(self, path: str) -> None:
                 tmp_mask_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
                 tmp_mask_file.close()
                 work_mask_path = tmp_mask_file.name
+
+                tmp_mask_file = None
                 copy(mask_path, f"file://{work_mask_path}") 
             
-            ogr.GetDriverByName('GTiff').Open(work_mask_path)
+            mask_driver = gdal.IdentifyDriver(work_mask_path).ShortName
+            if 'GTiff' != mask_driver:
+                raise Exception(f"Mask file '{mask_path}' is not a TIFF image. (GDAL driver : '{mask_driver}'")
 
             self.mask = mask_path
         else:
             self.mask = None
 
-        self.bbox = _compute_bbox()
-        self.samples = _compute_samples()
+        self.bbox = _compute_bbox(image_datasource)
+        self.samples = image_datasource.RasterCount
 
         tmp_image_file = None
 
 
-def _compute_bbox() -> tuple:
-    return None
+def _compute_bbox(source_dataset: gdal.Dataset) -> tuple:
+    """Image boundingbox computing method
+
+    Args:
+        source_dataset (gdal.Dataset): Dataset object created from the raster image
+
+    Raises:
+        AttributeError: source_dataset is not a gdal.Dataset instance.
+        Exception: The dataset does not contain transform data.
+    """
+
+    transform_vector = source_dataset.GetGeoTransform()
+
+    if transform_vector is None:
+        raise Exception(f"No transform vector found in the dataset created from the following file : {source_dataset.GetFileList()[0]}")
+
+    width = source_dataset.RasterXSize
+    height = source_dataset.RasterYSize
+
+    x_range = (
+        transform_vector[0],
+        transform_vector[0] + width * transform_vector[1] + height * transform_vector[2]
+    )
+
+    y_range = (
+        transform_vector[3],
+        transform_vector[3] + width * transform_vector[4] + height * transform_vector[5]
+    )
+
+    bbox = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+    )
 
+    return bbox
 
-def _compute_samples() -> int:
-    return None
 
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 4cc7c55..e4e196e 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,8 +1,11 @@
 """Describes unit tests for the rok4.Raster module."""
 
-from rok4.Raster import *
+from rok4.Raster import Raster, _compute_bbox
 from rok4.Storage import StorageType
 
+from osgeo import gdal
+import random
+
 import pytest
 from unittest.mock import *
 from unittest import mock, TestCase, skip
@@ -48,16 +51,19 @@ def setUp(self):
         
         self.get_infos_from_path = (StorageType.FILE, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
 
+        self.bbox = (-5.4, 41.3, 9.8, 51.3)
+
 
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_samples', return_value=3)
-    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path):
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path):
         """Test case : Constructor called nominally on an image without mask."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_compute_bbox.return_value = self.bbox
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
 
         raster_object = Raster( self.path['image']['full'] )
 
@@ -68,39 +74,35 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples,
         assert raster_object.mask is None
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
-
-        mocked_compute_samples.assert_called_once()
+        assert raster_object.bbox == self.bbox
         assert raster_object.samples == 3
 
 
-    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_samples', return_value=3)
-    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_get_driver):
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver):
         """Test case : Constructor called nominally on an image with mask."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        # This next line emulates the return of ogr.GetDriverByName()
-        # TODO : manage to implent this using unittest.mock
-        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+        mocked_compute_bbox.return_value = self.bbox
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
 
         raster_object = Raster(self.path['image']['full'])
 
         mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
         mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_get_driver.assert_called_once_with('GTiff')
-        mocked_gdal_open.assert_has_calls([ call(self.path['image']['system']), call(self.path['mask']['system']) ])
+        mocked_identifydriver.assert_called_once_with(self.path['mask']['system'])
+        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
         assert raster_object.path == self.path['image']['full']
         assert raster_object.mask == self.path['mask']['full']
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
-
-        mocked_compute_samples.assert_called_once()
+        assert raster_object.bbox == self.bbox
         assert raster_object.samples == 3
 
 
@@ -119,24 +121,23 @@ def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_
         mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
 
 
-    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=[None, RuntimeError])
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_get_driver):
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver):
         """Test case : Constructor called on an unsupported mask file or object."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        # This next line emulates the return of ogr.GetDriverByName()
-        # TODO : manage to implent this using unittest.mock
-        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
 
-        with pytest.raises(RuntimeError):
+        with pytest.raises(Exception):
             Raster(self.path['image']['full'])      
 
         mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_get_driver.assert_called_once_with('GTiff')
-        mocked_gdal_open.assert_has_calls([ call(self.path['image']['system']), call(self.path['mask']['system']) ])
+        mocked_identifydriver.assert_called_once_with(self.path['mask']['system'])
+        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
 
 
 
@@ -169,21 +170,23 @@ def setUp(self):
         self.tmp_path['image']['full'] = f"file://{self.tmp_path['image']['system']}"
         self.tmp_path['mask']['full'] = f"file://{self.tmp_path['mask']['system']}"
 
+        self.bbox = (-5.4, 41.3, 9.8, 51.3)
+
 
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_samples', return_value=3)
-    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
         """Test case : Constructor called nominally on an image without mask."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_compute_bbox.return_value = self.bbox
         mocked_tmp_file_close = Mock()
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
         # This next line emulates the return of tempfile.NamedTemporaryFile()
-        # TODO : manage to implent this using unittest.mock
         mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
 
         raster_object = Raster(self.path['image']['full'])
@@ -197,34 +200,31 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples,
         assert raster_object.mask is None
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
-
-        mocked_compute_samples.assert_called_once()
+        assert raster_object.bbox == self.bbox
         assert raster_object.samples == 3
 
 
-    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_samples', return_value=3)
-    @mock.patch('rok4.Raster._compute_bbox', return_value=[-5.4, 41.3, 9.8, 51.3])
+    @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute_samples, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_get_driver):
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver):
         """Test case : Constructor called nominally on an image with mask."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
+        mocked_compute_bbox.return_value = self.bbox
         mocked_tmp_file_close = Mock()
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
         # This next instruction emulates the return of tempfile.NamedTemporaryFile()
-        # TODO : manage to implent this using unittest.mock
         mocked_create_temporary_file.side_effect = [
             type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
             type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
         ]
-        # This next line emulates the return of ogr.GetDriverByName()
-        # TODO : manage to implent this using unittest.mock
-        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
 
         raster_object = Raster(self.path['image']['full'])
 
@@ -236,15 +236,13 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_compute
         mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
         mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
         mocked_copy.assert_has_calls(expected_copy_calls)
-        mocked_get_driver.assert_called_once_with('GTiff')
-        mocked_gdal_open.assert_has_calls([ call(self.tmp_path['image']['system']), call(self.tmp_path['mask']['system']) ])
+        mocked_identifydriver.assert_called_once_with(self.tmp_path['mask']['system'])
+        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
         assert raster_object.path == self.path['image']['full']
         assert raster_object.mask == self.path['mask']['full']
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == [-5.4, 41.3, 9.8, 51.3]
-
-        mocked_compute_samples.assert_called_once()
+        assert raster_object.bbox == self.bbox
         assert raster_object.samples == 3
 
     
@@ -259,7 +257,6 @@ def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
         mocked_tmp_file_close = Mock()
         # This next line emulates the return of tempfile.NamedTemporaryFile()
-        # TODO : manage to implent this using unittest.mock
         mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
 
         with pytest.raises(RuntimeError):
@@ -272,28 +269,26 @@ def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_
         mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
 
 
-    @mock.patch('rok4.Raster.ogr.GetDriverByName')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
     @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=[None, RuntimeError])
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_get_driver):
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver):
         """Test case : Constructor called on an unsupported mask file or object."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
         mocked_tmp_file_close = Mock()
         # This next instruction emulates the return of tempfile.NamedTemporaryFile()
-        # TODO : manage to implent this using unittest.mock
         mocked_create_temporary_file.side_effect = [
             type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
             type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
         ]
-        # This next line emulates the return of ogr.GetDriverByName()
-        # TODO : manage to implent this using unittest.mock
-        mocked_get_driver.return_value = type('', (object,), {'Open': mocked_gdal_open})
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
 
-        with pytest.raises(RuntimeError):
+        with pytest.raises(Exception):
             Raster(self.path['image']['full'])
 
         expected_copy_calls = [
@@ -304,16 +299,52 @@ def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_g
         mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
         mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
         mocked_copy.assert_has_calls(expected_copy_calls)
-        mocked_get_driver.assert_called_once_with('GTiff')
-        mocked_gdal_open.assert_has_calls([ call(self.tmp_path['image']['system']), call(self.tmp_path['mask']['system']) ])
+        mocked_identifydriver.assert_called_once_with(self.tmp_path['mask']['system'])
+        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
 
 
 
 class TestComputeBbox(TestCase):
     """Test class for the rok4.Raster._compute_bbox function."""
 
+    def test_nominal(self):
+        mocked_datasource = MagicMock(gdal.Dataset)
+        random.seed()
+
+        image_size = (
+            random.randint(1, 1000),
+            random.randint(1, 1000)
+        )
+        mocked_datasource.RasterXSize = image_size[0]
+        mocked_datasource.RasterYSize = image_size[1]
+
+        transform_tuple = (
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000)
+        )
+        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+
+        x_range = (
+            transform_tuple[0],
+            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+        )
+        y_range = (
+            transform_tuple[3],
+            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+        )
+
+        expected = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+        )
+        result = _compute_bbox(mocked_datasource)
+        assert expected == result
 
 
-class TestComputeSamples(TestCase):
-    """Test class for the rok4.Raster._compute_samples function."""
 

From 27918896016b40354317bcef04ac460c23fff320 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Thu, 16 Mar 2023 16:12:07 +0100
Subject: [PATCH 05/89] Ajout copie HTTP -> FILE/S3/CEPH

---
 src/rok4/Storage.py   | 135 +++++++++++++++++++++++------
 tests/test_Storage.py | 192 ++++++++++++++++++++++++++++++++++--------
 2 files changed, 268 insertions(+), 59 deletions(-)

diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index db4ec6c..e8a8a7f 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -4,6 +4,8 @@
 - S3 (path are preffixed with `s3://`)
 - CEPH (path are preffixed with `ceph://`)
 - FILE (path are preffixed with `file://`, but it is the default paths' interpretation)
+- HTTP (path are preffixed with `https://`)
+- HTTPS (path are preffixed with `https://`)
 
 According to functions, all storage types are not necessarily available.
 
@@ -35,6 +37,7 @@
 import os
 import rados
 import hashlib
+import requests
 from typing import Dict, List, Tuple
 from enum import Enum
 from shutil import copyfile
@@ -45,6 +48,8 @@ class StorageType(Enum):
     FILE = "file://"
     S3 = "s3://"
     CEPH = "ceph://"
+    HTTP = "http://"
+    HTTPS = "https://"
 
 __S3_CLIENTS = dict()
 __S3_DEFAULT_CLIENT = None
@@ -62,7 +67,7 @@ def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
 
     Returns:
         Tuple['boto3.client', str, str]: the S3 client, the cluster host and the simple bucket name
-    """    
+    """
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
 
     if not __S3_CLIENTS:
@@ -113,7 +118,7 @@ def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
 
 def disconnect_s3_clients() -> None:
     """Clean S3 clients
-    """    
+    """
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
     __S3_CLIENTS = dict()
     __S3_DEFAULT_CLIENT = None
@@ -134,7 +139,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:
@@ -146,7 +151,7 @@ def __get_ceph_ioctx(pool: str) -> 'rados.Ioctx':
             )
 
             __CEPH_CLIENT.connect()
-            
+
         except KeyError as e:
             raise MissingEnvironmentError(e)
         except Exception as e:
@@ -157,12 +162,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()
@@ -173,8 +178,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:
@@ -192,6 +197,10 @@ def get_infos_from_path(path: str) -> Tuple[StorageType, str, str, str]:
         return StorageType.CEPH, path[7:], pool_name, object_name
     elif path.startswith("file://"):
         return StorageType.FILE, path[7:], os.path.dirname(path[7:]), os.path.basename(path[7:])
+    elif path.startswith("http://"):
+        return StorageType.HTTP, path, "NULL", "NULL"
+    elif path.startswith("https://"):
+        return StorageType.HTTPS, path, "NULL", "NULL"
     else:
         return StorageType.FILE, path, os.path.dirname(path), os.path.basename(path)
 
@@ -206,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)}"
 
 
@@ -247,7 +256,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:
@@ -262,10 +271,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, host, tray_name = __get_s3_client(tray_name)
 
         try:
@@ -285,7 +294,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:
@@ -307,11 +316,22 @@ 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 Exception as e:
             raise StorageError("FILE", e)
 
+    elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
+
+        try:
+            reponse = requests.get(path)
+            data = reponse.content
+            print(reponse.content)
+            if reponse.status_code == 404 :
+                raise StorageError("HTTP", "Requested file does not exist")
+        except Exception as e:
+            raise StorageError("HTTP", e)
+
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to read binary data")
 
@@ -334,7 +354,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, host, tray_name = __get_s3_client(tray_name)
 
         try:
@@ -347,7 +367,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:
@@ -412,6 +432,14 @@ def get_size(path: str) -> int:
         except Exception as e:
             raise StorageError("FILE", e)
 
+    elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
+
+        try:
+            reponse = requests.get(path)
+            return reponse.content.__sizeof__()
+        except Exception as e:
+            raise StorageError("HTTP", e)
+
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to get size")
 
@@ -461,6 +489,17 @@ def exists(path: str) -> bool:
 
         return os.path.exists(path)
 
+    elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
+
+        try:
+            reponse = requests.get(path)
+            if reponse.status_code == 200 :
+                return True
+            else :
+                return False
+        except Exception as e:
+            raise StorageError("HTTP", e)
+
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to test if exists")
 
@@ -529,7 +568,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)
@@ -545,13 +584,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, host, from_tray = __get_s3_client(from_tray)
 
         try:
             if to_tray != "":
                 os.makedirs(to_tray, exist_ok=True)
-            
+
             s3_client.download_file(from_tray, from_base_name, to_path)
 
             if from_md5 is not None :
@@ -565,7 +604,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, host, to_tray = __get_s3_client(to_tray)
-        
+
         try:
             s3_client.upload_file(from_path, to_tray, to_base_name)
 
@@ -587,7 +626,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                     {
                         'Bucket': from_tray,
                         'Key': from_base_name
-                    }, 
+                    },
                     to_tray, to_base_name
                 )
             else:
@@ -602,7 +641,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 :
 
@@ -644,7 +683,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()
 
@@ -706,7 +745,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)
@@ -749,6 +788,52 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         except Exception as e:
             raise StorageError(f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}")
 
+    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.FILE :
+
+        try:
+            reponse = requests.get(from_path, stream = True)
+            with open(to_path, "wb") as f:
+                for chunk in reponse.iter_content(chunk_size=65536) :
+                    if chunk:
+                        f.write(chunk)
+
+        except Exception as e:
+            raise StorageError(f"HTTP(S) and FILE", f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}")
+
+    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.CEPH :
+
+        to_ioctx = __get_ceph_ioctx(to_tray)
+
+        try:
+            reponse = requests.get(from_path, stream = True)
+            offset = 0
+            for chunk in reponse.iter_content(chunk_size=65536) :
+                if chunk:
+                    to_ioctx.write(to_base_name, chunk, offset)
+                    offset += 65536
+
+        except Exception as e:
+            raise StorageError(f"HTTP(S) and CEPH", f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}")
+
+    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.S3 :
+
+        to_s3_client, to_host, to_tray = __get_s3_client(to_tray)
+
+        try:
+            reponse = requests.get(from_path, stream = True)
+            with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
+                name_fich = f.name
+                for chunk in reponse.iter_content(chunk_size=65536) :
+                    if chunk:
+                        f.write(chunk)
+
+            to_s3_client.upload_file(name_fich, to_tray, to_base_name)
+
+            os.remove(name_fich)
+
+        except Exception as e:
+            raise StorageError(f"HTTP(S) and S3", f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}")
+
     else:
         raise StorageError(f"{from_type.name} and {to_type.name}", f"Cannot copy from {from_type.name} to {to_type.name}")
 
@@ -795,7 +880,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:
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 175568c..985a1ea 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(StorageError):
         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):
 
@@ -128,10 +128,36 @@ def test_ceph_read_ok(mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH read raises an exception: {exc}"
 
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch("requests.get", side_effect={"status_code":404})
+def test_http_read_error(mock_http):
+    with pytest.raises(StorageError):
+        requests_instance = MagicMock()
+        requests_instance.content = "NULL"
+        requests_instance.status_code = 404
+        mock_http.return_value = requests_instance
+        data = get_data_str("http:///path/to/file.ext")
+
+    mock_http.assert_called_with("http:///path/to/file.ext")
+
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch("requests.get")
+def test_http_read_ok(mock_http):
+    try :
+        requests_instance = MagicMock()
+        requests_instance.content = b'data'
+        mock_http.return_value = requests_instance
+
+        data = get_data_str("http:///path/to/file.ext")
+        mock_http.assert_called_with("http:///path/to/file.ext")
+        assert data == 'data'
+    except Exception as exc:
+        assert False, f"HTTP read raises an exception: {exc}"
+
 
 ############ 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 +170,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 +184,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 +216,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 +236,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 +252,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 +268,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 +284,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 +300,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 +313,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 +332,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 +349,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 +368,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")
@@ -367,6 +393,69 @@ def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH -> S3 copy raises an exception: {exc}"
 
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch('requests.get')
+@patch('builtins.open', new_callable=mock_open)
+def test_copy_http_file_ok(mock_open, mock_requests):
+    try:
+
+        http_instance = MagicMock()
+        http_instance.iter_content.return_value = ["data","data2"]
+        mock_requests.return_value = http_instance
+
+        copy("http:///path/to/source.ext", "file:///path/to/destination.ext")
+        mock_requests.assert_called_once_with("http:///path/to/source.ext", stream=True)
+        mock_open.assert_called_once_with("/path/to/destination.ext", "wb")
+    except Exception as exc:
+        assert False, f"HTTP -> 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('rok4.Storage.rados.Rados')
+@mock.patch('requests.get')
+def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
+    try:
+
+        http_instance = MagicMock()
+        http_instance.iter_content.return_value = ["data","data2"]
+        mock_requests.return_value = http_instance
+
+
+        disconnect_ceph_clients()
+        ioctx_instance = MagicMock()
+        ioctx_instance.write.return_value = None
+        ceph_instance = MagicMock()
+        ceph_instance.open_ioctx.return_value = ioctx_instance
+        mocked_rados_client.return_value = ceph_instance
+
+        copy("http:///path/to/source.ext", "ceph://pool1/source.ext")
+        mock_requests.assert_called_once_with("http:///path/to/source.ext", stream=True)
+    except Exception as exc:
+        assert False, f"HTTP -> CEPH 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('rok4.Storage.boto3.client')
+@mock.patch('requests.get')
+@patch('tempfile.NamedTemporaryFile', new_callable=mock_open)
+@mock.patch('os.remove')
+def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_client):
+    try:
+
+        http_instance = MagicMock()
+        http_instance.iter_content.return_value = ["data","data2"]
+        mock_requests.return_value = http_instance
+
+        disconnect_s3_clients()
+        s3_instance = MagicMock()
+        s3_instance.upload_file.return_value = None
+        s3_instance.head_object.return_value = {"ETag": "8d777f385d3dfec8815d20f7496026dc"}
+        mocked_s3_client.return_value = s3_instance
+
+        copy("http:///path/to/source.ext", "s3://bucket/destination.ext")
+        mock_requests.assert_called_once_with("http:///path/to/source.ext", stream=True)
+        mock_tempfile.assert_called_once_with("w+b",delete=False)
+    except Exception as exc:
+        assert False, f"HTTP -> CEPH copy raises an exception: {exc}"
+
 
 
 ############ link
@@ -379,7 +468,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 +478,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 +487,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 +504,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 +519,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 +533,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 +543,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 +561,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):
 
@@ -487,10 +576,24 @@ def test_size_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"S3 size raises an exception: {exc}"
 
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch('requests.get')
+def test_size_http_ok(mock_requests):
+
+    http_instance = MagicMock()
+    http_instance.content.__sizeof__.return_value = 12
+    mock_requests.return_value = http_instance
+
+    try:
+        size = get_size("http:///path/to/file.ext")
+        assert size == 12
+    except Exception as exc:
+        assert False, f"HTTP size raises an exception: {exc}"
+
 
 ############ 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 +607,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 +630,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):
 
@@ -547,10 +650,31 @@ def test_exists_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"CEPH not exists raises an exception: {exc}"
 
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch('requests.get')
+def test_exists_http_ok(mock_requests):
+
+    http_instance = MagicMock()
+    http_instance.status_code = 200
+    mock_requests.return_value = http_instance
+
+    try:
+        assert exists("http:///path/to/file.ext")
+    except Exception as exc:
+        assert False, f"HTTP exists raises an exception: {exc}"
+
+    http_instance.status_code = 404
+    mock_requests.return_value = http_instance
+
+    try:
+        assert not exists("http:///path/to/file.ext")
+    except Exception as exc:
+        assert False, f"HTTP exists raises an exception: {exc}"
+
 
 ############ 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 +689,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 +712,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):
 
@@ -600,4 +724,4 @@ def test_remove_s3_ok(mocked_s3_client):
     try:
         remove("s3://bucket/object.ext")
     except Exception as exc:
-        assert False, f"S3 deletion raises an exception: {exc}"
\ No newline at end of file
+        assert False, f"S3 deletion raises an exception: {exc}"

From 298f0c58ee400538006d3a2f4e842e35ae65eb79 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Thu, 16 Mar 2023 16:30:23 +0100
Subject: [PATCH 06/89] =?UTF-8?q?Mise=20=C3=A0=20jour=20du=20CHANGELOG.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md | 21 +++------------------
 1 file changed, 3 insertions(+), 18 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a62581..256187b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,29 +1,14 @@
 ## Summary
 
-Ajout de fonctionnalités de lecture de donnée d'une pyramide et suivi des recommandations PyPA pour la gestion du projet.
+Ajout du type de stockage HTTP.
 
 ## Changelog
 
 ### [Added]
 
-* TileMatrix :
-    * Fonction de calcul des indices de tuile et de pixel dans la tuile à partir d'un point dans le système de coordonnées du TMS
-* Pyramid :
-    * Fonction de calcul des indices de tuile et de pixel dans la tuile à partir d'un point dans le système de coordonnées du TMS et éventuellement un niveau
-    * Fonctions de lecture d'une tuile : au format binaire source ou au format tableau à 3 dimensions pour les tuiles raster
 * Storage :
-    * Fonction de lecture binaire, complète ou partielle, d'un fichier ou objet S3 ou CEPH
-* Exceptions : NotImplementedError permet de préciser qu'une fonctionnalité n'a pas été implémentée pour tous les cas. Ici, on ne gère pas la décompression des données raster pour les compressions packbit et LZW
-  
-* Ajout de la publication PyPI dans la CI GitHub 
-
-### [Changed]
-
-* Storage :
-    * La lecture sous forme de chaîne s'appuie sur la lecture complète binaire. Aucun changement à l'usage.
-* TileMatrixSet : quelque soit le système de coordonnées, on ne gère que un ordre des axes X,Y ou Lon,Lat. Cependant, les fonctions de calcul de ou à partir de bbox respectent l'ordre du système dans ces dernières.
-
-* Passage de la configuration du projet dans le fichier `pyproject.toml`
+    * Ajout de la copie de HTTP vers FILE/S3/CEPH
+    * Ajout de la fonction de lecture d'un fichier HTTP, de l'existence d'un fichier HTTP et du calcul de taille d'un fichier HTTP
 
 <!--
 ### [Added]

From 247bcb145567ba7537b08fab2e4acb7af29c1d7c Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 17 Mar 2023 13:00:59 +0100
Subject: [PATCH 07/89] =?UTF-8?q?D=C3=A9codage=20d'une=20tuile=20vecteur?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Comme pour le raster, il est possible de récupérer le contenu d'une
tuile vecteur décodé. On obtient alors un dictionnaire au format GeoJSON

Pour mieux gérer le cas où la tuile voulue appartient à une dalle qui
n'existe pas, la fonction de lecture d'un fichier ou objet émet une
exception FileNotFoundError. Dans la lecture de utile, on sort une
donnée nulle et non une exception.
---
 CHANGELOG.md                                  |  22 +++-----
 pyproject.toml                                |   3 +-
 src/rok4/Pyramid.py                           |  49 +++++++++++++++++-
 src/rok4/Storage.py                           |  15 ++++++
 tests/fixtures/TIFF_PBF_MVT.json              |  23 ++++++++
 .../fixtures/TIFF_PBF_MVT/DATA/4/00/00/21.tif | Bin 0 -> 124838 bytes
 tests/test_Pyramid.py                         |  35 +++++++++++--
 tests/test_Storage.py                         |   2 +-
 8 files changed, 128 insertions(+), 21 deletions(-)
 create mode 100644 tests/fixtures/TIFF_PBF_MVT.json
 create mode 100644 tests/fixtures/TIFF_PBF_MVT/DATA/4/00/00/21.tif

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 28188cb..f8ecadd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,27 +1,21 @@
 ## Summary
 
-
+Fonction de lecture d'une tuile vecteur décodée.
 
 ## Changelog
 
 ### [Added]
 
-* Level
-    * Fonction de test d'une tuile `is_in_limits` : ses indices sont ils dans les limites du niveau ?
 * Pyramid
-    * La lecture d'une tuile vérifie avant que les indices sont bien dans les limites du niveau
-    * Les exceptions levées lors du décodage de la tuile raster emettent une exception `FormatError`
-    * `get_tile_indices` accepte en entrée un système de coordonnées : c'est celui des coordonnées fournies et permet de faire une reprojection si celui ci n'est pas le même que celui des données dans la pyramide
-* Utils
-    * Meilleure gestion de reprojection par `reproject_bbox` : on détecte des systèmes identiques en entrée ou quand seul l'ordre des axes changent, pour éviter le calcul
-    * Ajout de la fonction de reprojection d'un point `reproject_point` : on détecte des systèmes identiques en entrée ou quand seul l'ordre des axes changent, pour éviter le calcul
-  
+    * Décodage d'une tuile vecteur avec `get_tile_data_vector` (le pendant vecteur de `get_tile_data_raster`) : le résultat est un "dictionnaire GeoJSON", et les coordonnées sont en relatif à la tuile (souvent entre 0 et 4096)
+
 ### [Changed]
 
-* Utils :
-    * `bbox_to_geometry` : on ne fournit plus de système de coordonnées, la fonction se content de créer la géométrie OGR à partir de la bbox, avec éventuellement une densification en points des bords
-* Pyramid :
-    * Renommage de fonction : `update_limits` -> `set_limits_from_bbox`. Le but est d'être plus explicite sur le fonctionnement de la fonction (on écrase les limites, on ne les met pas juste à jour par union avec la bbox fournie)
+* Storage
+    * La lecture d'un fichier ou objet qui n'existe pas émet toujours une exception `FileNotFoundError`
+* Pyramid
+    * Si la tuile que l'on veut lire est dans une dalle qui n'existe pas, on retourne `None`
+
 <!--
 ### [Added]
 
diff --git a/pyproject.toml b/pyproject.toml
index 04310a2..a44b15f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -33,7 +33,8 @@ classifiers = [
 dependencies = [
   "boto3 >= 1.26.54",
   "pillow >= 9.4.0",
-  "numpy >= 1.24.2"
+  "numpy >= 1.24.2",
+  "mapbox-vector-tile >= 2.0.1"
 ]
 
 [project.optional-dependencies]
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 0cb693e..1956584 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -14,6 +14,7 @@
 import numpy
 import zlib
 import io
+import mapbox_vector_tile
 from PIL import Image
 
 from rok4.Exceptions import *
@@ -815,7 +816,12 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         # 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)
-        binary_index = get_data_binary(slab_path, (2048, 2 * 4 * level_object.slab_width * level_object.slab_height))
+        try:
+            binary_index = get_data_binary(slab_path, (2048, 2 * 4 * level_object.slab_width * level_object.slab_height))
+        except FileNotFoundError as e:
+            # L'absence de la dalle est gérée comme simplement une absence de données
+            return None
+
         offsets = numpy.frombuffer(
             binary_index,
             dtype = numpy.dtype('uint32'),
@@ -928,6 +934,47 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
 
         return data
 
+    def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
+        """Get a vector pyramid's tile as GeoJSON dictionnary
+
+        Args:
+            level (str): Tile's level
+            column (int): Tile's column
+            row (int): Tile's row
+
+        Raises:
+            Exception: Cannot get vector data for a raster pyramid
+            Exception: Level not found in the pyramid
+            NotImplementedError: Pyramid owns one-tile slabs
+            NotImplementedError: Vector pyramid format not handled
+            MissingEnvironmentError: Missing object storage informations
+            StorageError: Storage read issue
+            FormatError: Cannot decode tile
+
+        Returns:
+            str: data, as GeoJSON dictionnary. None if no data
+        """
+
+        if self.type == PyramidType.RASTER:
+            raise Exception("Cannot get tile as vector data : it's a raster pyramid")
+
+        binary_tile = self.get_tile_data_binary(level, column, row)
+
+        if binary_tile is None:
+            return None
+
+        level_object = self.get_level(level)
+
+        if self.__format == "TIFF_PBF_MVT":
+            try:
+                data = mapbox_vector_tile.decode(binary_tile)
+            except Exception as e:
+                raise FormatError("PBF (MVT)", "binary tile", e)
+        else:
+            raise NotImplementedError(f"Cannot get tile as vector data for format {self.__format}")
+
+        return data
+
     def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> Tuple[str, int, int, int, int]:
         """Get pyramid's tile and pixel indices from point's coordinates
 
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index db4ec6c..a10d1f8 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -239,6 +239,7 @@ def get_data_str(path: str) -> str:
     Raises:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage read issue
+        FileNotFoundError: File or object does not exist
 
     Returns:
         str: Data content
@@ -257,6 +258,7 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
     Raises:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage read issue
+        FileNotFoundError: File or object does not exist
 
     Returns:
         str: Data binary content
@@ -281,6 +283,12 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
                     Range=f"bytes=${range[0]}-${range[1] - range[0] - 1}"
                 )['Body'].read()
 
+        except botocore.exceptions.ClientError as e:
+            if e.response['Error']['Code'] == "404":
+                raise FileNotFoundError(f"{storage_type.value}{path}")
+            else:
+                raise StorageError("S3", e)
+
         except Exception as e:
             raise StorageError("S3", e)
 
@@ -295,6 +303,9 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             else:
                 data = ioctx.read(base_name, range[1], range[0])
 
+        except rados.ObjectNotFound as e:
+            raise FileNotFoundError(f"{storage_type.value}{path}")
+
         except Exception as e:
             raise StorageError("CEPH", e)
 
@@ -309,6 +320,10 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
                 data = f.read(range[1])
             
             f.close()
+
+        except FileNotFoundError as e:
+            raise FileNotFoundError(f"{storage_type.value}{path}")
+
         except Exception as e:
             raise StorageError("FILE", e)
 
diff --git a/tests/fixtures/TIFF_PBF_MVT.json b/tests/fixtures/TIFF_PBF_MVT.json
new file mode 100644
index 0000000..e0dbdc7
--- /dev/null
+++ b/tests/fixtures/TIFF_PBF_MVT.json
@@ -0,0 +1,23 @@
+{
+    "levels": [
+        {
+            "storage": {
+                "image_directory": "TIFF_PBF_MVT/DATA/4",
+                "type": "FILE",
+                "path_depth": 2
+            },
+            "tables": [],
+            "id": "4",
+            "tiles_per_height": 4,
+            "tile_limits": {
+                "max_col": 15,
+                "min_col": 0,
+                "max_row": 25,
+                "min_row": 0
+            },
+            "tiles_per_width": 4
+        }
+    ],
+    "format": "TIFF_PBF_MVT",
+    "tile_matrix_set": "PM"
+}
\ No newline at end of file
diff --git a/tests/fixtures/TIFF_PBF_MVT/DATA/4/00/00/21.tif b/tests/fixtures/TIFF_PBF_MVT/DATA/4/00/00/21.tif
new file mode 100644
index 0000000000000000000000000000000000000000..f58bff76d4c14d85f464317221a38e508cc97b62
GIT binary patch
literal 124838
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
UTMhd`Eud;Di_jA!U6c8L03Lc80ssI2

literal 0
HcmV?d00001

diff --git a/tests/test_Pyramid.py b/tests/test_Pyramid.py
index cfd86eb..7a888a6 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_Pyramid.py
@@ -158,7 +158,7 @@ def test_vector_ok(mocked_tms_class, mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch('rok4.Pyramid.TileMatrixSet')
-def test_tile_read(mocked_tms_class):
+def test_tile_read_raster(mocked_tms_class):
 
     tms_instance = MagicMock()
     tms_instance.name = "UTM20W84MART_1M_MNT"
@@ -166,8 +166,6 @@ def test_tile_read(mocked_tms_class):
     
     tm_instance = MagicMock()
     tm_instance.id = "8"
-    tm_instance.resolution = 1
-    tm_instance.point_to_indices.return_value = (0,0,128,157)
     tm_instance.tile_size = (256,256)
 
     tms_instance.get_level.return_value = tm_instance
@@ -181,8 +179,37 @@ def test_tile_read(mocked_tms_class):
         assert data.shape == (256,256,1)
         assert data[128][128][0] == 447.25
     except Exception as exc:
-        assert False, f"Pyramid creation raises an exception: {exc}"
+        assert False, f"Pyramid raster tile read raises an exception: {exc}"
+
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch('rok4.Pyramid.TileMatrixSet')
+def test_tile_read_vector(mocked_tms_class):
 
+    tms_instance = MagicMock()
+    tms_instance.name = "PM"
+    tms_instance.srs = "EPSG:3857"
+    
+    tm_instance = MagicMock()
+    tm_instance.id = "4"
+    tm_instance.tile_size = (256,256)
+
+    tms_instance.get_level.return_value = tm_instance
+
+    mocked_tms_class.return_value = tms_instance
+
+    try:
+        pyramid = Pyramid.from_descriptor("file://tests/fixtures/TIFF_PBF_MVT.json")
+
+        data = pyramid.get_tile_data_vector("4", 5, 5)
+        assert data is None
+
+        data = pyramid.get_tile_data_vector("4", 8, 5)
+        assert type(data) is dict
+        assert "ecoregions_3857" in data
+    except Exception as exc:
+        assert False, f"Pyramid vector tile read raises an exception: {exc}"
 
 def test_b36_path_decode():
     assert b36_path_decode("3E/42/01.tif") == (4032, 18217,)
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 175568c..4c1d05b 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -64,7 +64,7 @@ def test_s3_invalid_endpoint(mocked_s3_client):
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("builtins.open", side_effect=FileNotFoundError("not_found"))
 def test_file_read_error(mock_file):
-    with pytest.raises(StorageError):
+    with pytest.raises(FileNotFoundError):
         data = get_data_str("file:///path/to/file.ext")
     
     mock_file.assert_called_with("/path/to/file.ext", "rb")

From ce0f152a4d9f38dc103c22570622436ce05f53d4 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Fri, 17 Mar 2023 14:36:53 +0100
Subject: [PATCH 08/89] Gestion des fichiers lourds

---
 src/rok4/Storage.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index e8a8a7f..a46e13f 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -324,7 +324,7 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
 
         try:
-            reponse = requests.get(path)
+            reponse = requests.get(path, stream=True)
             data = reponse.content
             print(reponse.content)
             if reponse.status_code == 404 :
@@ -435,7 +435,7 @@ def get_size(path: str) -> int:
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
 
         try:
-            reponse = requests.get(path)
+            reponse = requests.get(path, stream=True)
             return reponse.content.__sizeof__()
         except Exception as e:
             raise StorageError("HTTP", e)
@@ -492,7 +492,7 @@ def exists(path: str) -> bool:
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
 
         try:
-            reponse = requests.get(path)
+            reponse = requests.get(path, stream=True)
             if reponse.status_code == 200 :
                 return True
             else :
@@ -809,8 +809,9 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             offset = 0
             for chunk in reponse.iter_content(chunk_size=65536) :
                 if chunk:
+                    size = len(chunk)
                     to_ioctx.write(to_base_name, chunk, offset)
-                    offset += 65536
+                    offset += size
 
         except Exception as e:
             raise StorageError(f"HTTP(S) and CEPH", f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}")

From 96b33245eb276d3f257ef37093b07c4d32e89e6b Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 17 Mar 2023 14:40:32 +0100
Subject: [PATCH 09/89] =?UTF-8?q?Ajout=20d'un=20cache=20=C3=A0=20la=20cr?=
 =?UTF-8?q?=C3=A9ation=20des=20spatial=20reference?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md      |  2 ++
 src/rok4/Utils.py | 24 +++++++++++++++++-------
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f8ecadd..a7e242b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,8 @@ Fonction de lecture d'une tuile vecteur décodée.
 
 * Pyramid
     * Décodage d'une tuile vecteur avec `get_tile_data_vector` (le pendant vecteur de `get_tile_data_raster`) : le résultat est un "dictionnaire GeoJSON", et les coordonnées sont en relatif à la tuile (souvent entre 0 et 4096)
+* Utils
+    * Ajout d'un cache pour la création de spatial reference (via la fonction `srs_to_spatialreference`)
 
 ### [Changed]
 
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 58f8a13..7f8260b 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -8,9 +8,12 @@
 ogr.UseExceptions()
 osr.UseExceptions()
 
+__SR_BOOK = dict()
 def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
     """Convert coordinates system as string to OSR spatial reference
 
+    Using a cache, to instanciate a Spatial Reference from a string only once.
+
     Args:
         srs (str): coordinates system PROJ4 compliant, with authority and code, like EPSG:3857 or IGNF:LAMB93
 
@@ -21,15 +24,22 @@ def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
         osgeo.osr.SpatialReference: Corresponding OSR spatial reference
     """
 
-    authority, code = srs.split(':', 1)
+    global __SR_BOOK
+
+    if srs.upper() not in __SR_BOOK:
+
+        authority, code = srs.split(':', 1)
+
+        sr = osr.SpatialReference()
+        if authority.upper() == "EPSG":
+            sr.ImportFromEPSG(int(code))
+        else:
+            sr.ImportFromProj4(f"+init={srs.upper()} +wktext")
+
+        __SR_BOOK[srs.upper()] = sr
 
-    sr = osr.SpatialReference()
-    if authority.upper() == "EPSG":
-        sr.ImportFromEPSG(int(code))
-    else:
-        sr.ImportFromProj4(f"+init={srs.upper()} +wktext")
 
-    return sr
+    return __SR_BOOK[srs.upper()]
 
 def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int = 0) -> 'osgeo.ogr.Geometry':  
     """Convert bbox coordinates to OGR geometry

From b56e594273eb85b9263e968a317c7dd49e9830ee Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Mon, 20 Mar 2023 14:42:00 +0100
Subject: [PATCH 10/89] Ajout d'un gestionnaire de chemin GDAL
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Cela permet d'ouvrir un objet S3 avec GDAL ou OGR sans avoir à le télécharger entièrement, en utilisant les systèmes de fichiers virtuel.

Pour un fichier, seule l'extension est enlevée.

+ Correction de la lecture S3
---
 .github/workflows/build-and-release.yaml |  11 +-
 CHANGELOG.md                             |  21 +--
 README.md                                |   3 +
 src/rok4/Exceptions.py                   |   8 --
 src/rok4/Storage.py                      | 157 ++++++++++++++---------
 tests/test_Storage.py                    |  30 ++++-
 6 files changed, 150 insertions(+), 80 deletions(-)

diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 2802b78..40fb13e 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -73,7 +73,7 @@ jobs:
           echo "/usr/lib/python3/dist-packages/" >.venv/lib/python${{ matrix.python-version }}/site-packages/system.pth
 
       - name: Run unit tests
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           pip install -e .[test]
@@ -81,20 +81,20 @@ jobs:
           coverage report -m
 
       - name: Build unit tests report
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           coverage html -d dist/tests/
           rm dist/tests/.gitignore
 
       - name: Build package
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           python3 -m build
 
       - name: Build documentation
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           pip install -e .[doc]
@@ -102,7 +102,7 @@ jobs:
           cp README.md CHANGELOG.md dist/
 
       - name: Upload packages, tests results and documentation
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         uses: actions/upload-artifact@v3
         with:
           name: dist-py3
@@ -189,6 +189,7 @@ jobs:
           cat artifact/CHANGELOG.md >>docs/versions/${{ github.ref_name }}/CHANGELOG.md
           sed "s#__version__#${{ github.ref_name }}#" templates/README.template.md >docs/versions/${{ github.ref_name }}/README.md
           cat artifact/README.md >>docs/versions/${{ github.ref_name }}/README.md
+          sed -i "s#x.y.z#${{ github.ref_name }}#g" docs/versions/${{ github.ref_name }}/README.md
           sed "s#__version__#${{ github.ref_name }}#" templates/index.template.md >docs/index.md
           echo "# Versions" >docs/versions.md
           echo "" >>docs/versions.md
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a7e242b..8dd332d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,23 +1,28 @@
 ## Summary
 
-Fonction de lecture d'une tuile vecteur décodée.
+Lecture par système de fichier virtuel avec GDAL
 
 ## Changelog
 
 ### [Added]
 
-* Pyramid
-    * Décodage d'une tuile vecteur avec `get_tile_data_vector` (le pendant vecteur de `get_tile_data_raster`) : le résultat est un "dictionnaire GeoJSON", et les coordonnées sont en relatif à la tuile (souvent entre 0 et 4096)
-* Utils
-    * Ajout d'un cache pour la création de spatial reference (via la fonction `srs_to_spatialreference`)
+* Storage
+    * Fonction `get_osgeo_path` permettant de configurer le bon sytème de fichier virtuel en fonction du chemin fourni, et retourne celui à utiliser dans le Open de gdal ou ogr
 
 ### [Changed]
 
 * Storage
-    * La lecture d'un fichier ou objet qui n'existe pas émet toujours une exception `FileNotFoundError`
-* Pyramid
-    * Si la tuile que l'on veut lire est dans une dalle qui n'existe pas, on retourne `None`
+    * la récupération d'un client S3 (`__get_s3_client`) permet de récupérer le client, l'hôte, les clés d'accès et secrète, ainsi que le nom du bucket sans l'éventuel hôte du cluster
+
+### [Fixed]
+
+* Storage
+    * Lecture binaire S3 : mauvaise configuration du nom du bucket et de l'objet et mauvaise lecture partielle
+
+### [Removed]
 
+* Exceptions
+    * `NotImplementedError` est une exceptions native
 <!--
 ### [Added]
 
diff --git a/README.md b/README.md
index 400645d..191feab 100644
--- a/README.md
+++ b/README.md
@@ -16,8 +16,11 @@ Installations système requises :
 * debian : `apt install python3-rados python3-gdal`
 
 Depuis [PyPI](https://pypi.org/project/rok4/) : `pip install rok4`
+
 Depuis [GitHub](https://github.com/rok4/core-python/releases/) : `pip install https://github.com/rok4/core-python/releases/download/x.y.z/rok4-x.y.z-py3-none-any.whl`
 
+L'environnement d'exécution doit avoir accès aux librairies système. Dans le cas d'une utilisation au sein d'un environnement python, précisez bien à la création `python3 -m venv --system-site-packages .venv`.
+
 ## Utiliser la librairie
 
 ```python
diff --git a/src/rok4/Exceptions.py b/src/rok4/Exceptions.py
index 3f0ff4f..92c75e3 100644
--- a/src/rok4/Exceptions.py
+++ b/src/rok4/Exceptions.py
@@ -37,11 +37,3 @@ def __init__(self, expected_format, content, issue):
         self.content = content
         self.issue = issue
         super().__init__(f"Expected format {expected_format} to read '{content}' : {issue}")
-
-class NotImplementedError(Exception):
-    """
-    Exception raised when a feature could be provided but is not implemented yet
-    """
-
-    def __init__(self, issue):
-        super().__init__(issue)
\ No newline at end of file
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index a10d1f8..b0ced08 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -35,9 +35,12 @@
 import os
 import rados
 import hashlib
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Union
 from enum import Enum
 from shutil import copyfile
+from osgeo import gdal
+
+gdal.UseExceptions()
 
 from rok4.Exceptions import *
 
@@ -48,7 +51,7 @@ class StorageType(Enum):
 
 __S3_CLIENTS = dict()
 __S3_DEFAULT_CLIENT = None
-def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
+def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',str]], str, str]:
     """Get the S3 client
 
     Create it if not already done
@@ -61,7 +64,7 @@ def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
         StorageError: S3 client configuration issue
 
     Returns:
-        Tuple['boto3.client', str, str]: the S3 client, the cluster host and the simple bucket name
+        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
 
@@ -79,15 +82,21 @@ def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
 
                 h = re.sub("https?://", "", urls[i])
 
-                if urls[i] in __S3_CLIENTS:
+                if h in __S3_CLIENTS:
                     raise StorageError("S3", "A S3 cluster is defined twice (based on URL)")
 
-                __S3_CLIENTS[h] = boto3.client(
-                    's3',
-                    aws_access_key_id = keys[i],
-                    aws_secret_access_key = secret_keys[i],
-                    endpoint_url = urls[i]
-                )
+                __S3_CLIENTS[h] = {
+                    "client": boto3.client(
+                        's3',
+                        aws_access_key_id = keys[i],
+                        aws_secret_access_key = secret_keys[i],
+                        endpoint_url = urls[i]
+                    ),
+                    "key": keys[i],
+                    "secret_key": secret_keys[i],
+                    "url": urls[i],
+                    "host": h
+                }
 
                 if i == 0:
                     # Le premier cluster est celui par défaut
@@ -109,7 +118,7 @@ def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
     if host not in __S3_CLIENTS:
         raise StorageError("S3", f"Unknown S3 cluster, according to host '{host}'")
 
-    return __S3_CLIENTS[host], host, bucket_name
+    return __S3_CLIENTS[host], bucket_name
 
 def disconnect_s3_clients() -> None:
     """Clean S3 clients
@@ -268,19 +277,19 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
 
     if storage_type == StorageType.S3:
         
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
             if range is None:
-                data = s3_client.get_object(
-                    Bucket='tray_name',
-                    Key='base_name',
+                data = s3_client["client"].get_object(
+                    Bucket=bucket_name,
+                    Key=base_name,
                 )['Body'].read()
             else:
-                data = s3_client.get_object(
-                    Bucket='tray_name',
-                    Key='base_name',
-                    Range=f"bytes=${range[0]}-${range[1] - range[0] - 1}"
+                data = s3_client["client"].get_object(
+                    Bucket=bucket_name,
+                    Key=base_name,
+                    Range=f"bytes={range[0]}-{range[0] + range[1] - 1}"
                 )['Body'].read()
 
         except botocore.exceptions.ClientError as e:
@@ -350,12 +359,12 @@ def put_data_str(data: str, path: str) -> None:
 
     if storage_type == StorageType.S3:
         
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            s3_client.put_object(
+            s3_client["client"].put_object(
                 Body = data.encode('utf-8'),
-                Bucket = tray_name,
+                Bucket = bucket_name,
                 Key = base_name
             )
         except Exception as e:
@@ -401,10 +410,10 @@ def get_size(path: str) -> int:
 
     if storage_type == StorageType.S3:
 
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            size = s3_client.head_object(Bucket=tray_name, Key=base_name)["ContentLength"].strip('"')
+            size = s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)["ContentLength"].strip('"')
             return int(size)
         except Exception as e:
             raise StorageError("S3", e)
@@ -449,10 +458,10 @@ def exists(path: str) -> bool:
 
     if storage_type == StorageType.S3:
 
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            s3_client.head_object(Bucket=tray_name, Key=base_name)
+            s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)
             return True
         except botocore.exceptions.ClientError as e:
             if e.response['Error']['Code'] == "404":
@@ -493,11 +502,11 @@ def remove(path: str) -> None:
 
     if storage_type == StorageType.S3:
 
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            s3_client.delete_object(
-                Bucket=tray_name,
+            s3_client["client"].delete_object(
+                Bucket=bucket_name,
                 Key=base_name
             )
         except Exception as e:
@@ -561,13 +570,13 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
     elif from_type == StorageType.S3 and to_type == StorageType.FILE :
         
-        s3_client, host, from_tray = __get_s3_client(from_tray)
+        s3_client, from_bucket = __get_s3_client(from_tray)
 
         try:
             if to_tray != "":
                 os.makedirs(to_tray, exist_ok=True)
             
-            s3_client.download_file(from_tray, from_base_name, to_path)
+            s3_client["client"].download_file(from_bucket, from_base_name, to_path)
 
             if from_md5 is not None :
                 to_md5 = hash_file(to_path)
@@ -579,13 +588,13 @@ 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, host, to_tray = __get_s3_client(to_tray)
+        s3_client, to_bucket = __get_s3_client(to_tray)
         
         try:
-            s3_client.upload_file(from_path, to_tray, to_base_name)
+            s3_client["client"].upload_file(from_path, to_bucket, to_base_name)
 
             if from_md5 is not None :
-                to_md5 = s3_client.head_object(Bucket=to_tray, Key=to_base_name)["ETag"].strip('"')
+                to_md5 = s3_client["client"].head_object(Bucket=to_bucket, Key=to_base_name)["ETag"].strip('"')
                 if to_md5 != from_md5:
                     raise StorageError(f"FILE and S3", f"Invalid MD5 sum control for copy file {from_path} to S3 object {to_path} : {from_md5} != {to_md5}")
         except Exception as e:
@@ -593,25 +602,25 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
     elif from_type == StorageType.S3 and to_type == StorageType.S3 :
 
-        from_s3_client, from_host, from_tray = __get_s3_client(from_tray)
-        to_s3_client, to_host, to_tray = __get_s3_client(to_tray)
+        from_s3_client, from_bucket = __get_s3_client(from_tray)
+        to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            if to_host == from_host:
-                to_s3_client.copy(
+            if to_s3_client["host"] == from_s3_client["host"]:
+                to_s3_client["client"].copy(
                     {
-                        'Bucket': from_tray,
+                        'Bucket': from_bucket,
                         'Key': from_base_name
                     }, 
-                    to_tray, to_base_name
+                    to_bucket, to_base_name
                 )
             else:
                 with tempfile.NamedTemporaryFile("w+b") as f:
-                    from_s3_client.download_fileobj(from_tray, from_base_name, f)
-                    to_s3_client.upload_file(f.name, to_tray, to_base_name)
+                    from_s3_client["client"].download_fileobj(from_bucket, from_base_name, f)
+                    to_s3_client["client"].upload_file(f.name, to_bucket, to_base_name)
 
             if from_md5 is not None :
-                to_md5 = to_s3_client.head_object(Bucket=to_tray, Key=to_base_name)["ETag"].strip('"')
+                to_md5 = to_s3_client["client"].head_object(Bucket=to_bucket, Key=to_base_name)["ETag"].strip('"')
                 if to_md5 != from_md5:
                     raise StorageError(f"S3", f"Invalid MD5 sum control for copy S3 object {from_path} to {to_path} : {from_md5} != {to_md5}")
 
@@ -726,7 +735,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
         from_ioctx = __get_ceph_ioctx(from_tray)
 
-        to_s3_client, to_host, to_tray = __get_s3_client(to_tray)
+        s3_client, to_bucket = __get_s3_client(to_tray)
 
         if from_md5 is not None:
             checker = hashlib.md5()
@@ -736,7 +745,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             size = 0
 
             with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
-                name_fich = f.name
+                name_tmp = f.name
                 while True:
                     chunk = from_ioctx.read(from_base_name, 65536, offset)
                     size = len(chunk)
@@ -749,18 +758,13 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                     if size < 65536:
                         break
 
-            to_s3_client.upload_file(name_fich, to_tray, to_base_name)
+            s3_client["client"].upload_file(name_tmp, to_bucket, to_base_name)
 
-            os.remove(name_fich)
+            os.remove(name_tmp)
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
                 raise StorageError(f"CEPH and S3", f"Invalid MD5 sum control for copy CEPH object {from_path} to S3 object {to_path} : {from_md5} != {checker.hexdigest()}")
 
-            if from_md5 is not None :
-                to_md5 = to_s3_client.head_object(Bucket=to_tray, Key=to_base_name)["ETag"].strip('"')
-                if to_md5 != from_md5 and "-" not in to_md5:
-                    raise StorageError(f"CEPH and S3", f"Invalid MD5 sum control for copy CEPH object {from_path} to S3 object {to_path} : {from_md5} != {to_md5}")
-
         except Exception as e:
             raise StorageError(f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}")
 
@@ -794,16 +798,16 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
     # Réalisation du lien, selon les types de stockage
     if target_type == StorageType.S3:
 
-        target_s3_client, target_host, target_tray = __get_s3_client(target_tray)
-        link_s3_client, link_host, link_tray = __get_s3_client(link_tray)
+        target_s3_client, target_bucket = __get_s3_client(target_tray)
+        link_s3_client, link_bucket = __get_s3_client(link_tray)
 
-        if link_host != target_host:
+        if target_s3_client["host"] != link_s3_client["host"]:
             raise StorageError(f"S3", f"Cannot make link {link_path} -> {target_path} : link works only on the same S3 cluster")
 
         try:
-            target_s3_client.put_object(
-                Body = f"{__OBJECT_SYMLINK_SIGNATURE}{target_tray}/{target_base_name}".encode('utf-8'),
-                Bucket = link_tray,
+            target_s3_client["client"].put_object(
+                Body = f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode('utf-8'),
+                Bucket = link_bucket,
                 Key = link_base_name
             )
         except Exception as e:
@@ -830,3 +834,40 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
 
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to make link")
+
+def get_osgeo_path(path: str) -> str:
+    """Return GDAL/OGR Open compliant path and configure storage access
+
+    For a S3 input path, endpoint, access and secret keys are set and path is built with "/vsis3" root.
+
+    For a FILE input path, only storage prefix is removed
+
+    Args:
+        path (str): Source path
+
+    Raises:
+        NotImplementedError: Storage type not handled
+
+    Returns:
+        str: GDAL/OGR Open compliant path
+    """    
+
+    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
+
+
+    if storage_type == StorageType.S3:
+
+        s3_client, bucket_name = __get_s3_client(tray_name)
+
+        gdal.SetConfigOption('AWS_SECRET_ACCESS_KEY', s3_client["secret_key"])
+        gdal.SetConfigOption('AWS_ACCESS_KEY_ID', s3_client["key"])
+        gdal.SetConfigOption('AWS_S3_ENDPOINT', s3_client["host"])
+        gdal.SetConfigOption('AWS_VIRTUAL_HOSTING', 'FALSE')
+
+        return f"/vsis3/{bucket_name}/{base_name}"
+
+    elif storage_type == StorageType.FILE:
+        return unprefixed_path
+
+    else:
+        raise NotImplementedError(f"Cannot get a GDAL/OGR compliant path from {path}")
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 4c1d05b..40cb365 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -600,4 +600,32 @@ def test_remove_s3_ok(mocked_s3_client):
     try:
         remove("s3://bucket/object.ext")
     except Exception as exc:
-        assert False, f"S3 deletion raises an exception: {exc}"
\ No newline at end of file
+        assert False, f"S3 deletion raises an exception: {exc}"
+
+
+############ get_osgeo_path
+
+@mock.patch.dict(os.environ, {}, clear=True)
+def test_get_osgeo_path_file_ok():
+    try:
+        path = get_osgeo_path("file:///path/to/file.ext")
+        assert path == "/path/to/file.ext"
+    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) 
+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"
+    except Exception as exc:
+        assert False, f"S3 osgeo path raises an exception: {exc}"
+
+
+@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

From 5cb20f61cc878a97c74e0894e09afbd5d8d7159c Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Tue, 21 Mar 2023 17:02:45 +0100
Subject: [PATCH 11/89] =?UTF-8?q?Impl=C3=A9mentation=20dans=20la=20lib=20R?=
 =?UTF-8?q?aster=20de=20la=20d=C3=A9termination=20du=20format=20de=20codag?=
 =?UTF-8?q?e=20des=20couleurs.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md                 |   8 +-
 README.md                    |   6 +-
 {rok4 => src/rok4}/Raster.py |  63 ++++++++++++--
 tests/test_Raster.py         | 162 ++++++++++++++++++++++++++++++++---
 4 files changed, 218 insertions(+), 21 deletions(-)
 rename {rok4 => src/rok4}/Raster.py (53%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 604aa39..e409281 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,9 @@ Librairie de lecture d'une donnée raster.
     * Décodage d'une tuile vecteur avec `get_tile_data_vector` (le pendant vecteur de `get_tile_data_raster`) : le résultat est un "dictionnaire GeoJSON", et les coordonnées sont en relatif à la tuile (souvent entre 0 et 4096)
 * Utils
     * Ajout d'un cache pour la création de spatial reference (via la fonction `srs_to_spatialreference`)
+* Raster :
+  * Chargement des informations sur un fichier raster (chemin du fichier, chemin du fichier de masque si applicable, nombre de canaux, boundingbox de l'emprise géographique)
+  * Tests unitaires
 
 ### [Changed]
 
@@ -18,9 +21,8 @@ Librairie de lecture d'une donnée raster.
     * La lecture d'un fichier ou objet qui n'existe pas émet toujours une exception `FileNotFoundError`
 * Pyramid
     * Si la tuile que l'on veut lire est dans une dalle qui n'existe pas, on retourne `None`
-* Librairie "Raster" de lecture de données raster :
-  * Chargement des informations sur un fichier raster (chemin du fichier, chemin du fichier de masque si applicable, nombre de canaux, boundingbox de l'emprise géographique)
-  * Tests unitaires
+* README.md
+    * Modification du bloc code de compilation pour utiliser explicitement python3, et installer certaines dépendances.
 
 <!--
 ### [Added]
diff --git a/README.md b/README.md
index 400645d..fca66e4 100644
--- a/README.md
+++ b/README.md
@@ -36,14 +36,14 @@ except Exception as exc:
 ## Compiler la librairie
 
 ```sh
-apt install python3-venv
+apt install python3-venv python3-rados python3-gdal # user input required for gdal dependencies, unless DEBIAN_FRONTEND=noninteractive
 python3 -m venv .venv
 source .venv/bin/activate
 python3 -m pip install --upgrade build bump2version
 bump2version --allow-dirty --current-version 0.0.0 --new-version x.y.z patch pyproject.toml src/rok4/__init__.py
 
 # Run unit tests
-pip install -e .[test]
+python3 -m pip install -e .[test]
 # To use system installed modules rados and osgeo
 echo "/usr/lib/python3/dist-packages/" >.venv/lib/python3.10/site-packages/system.pth
 python -c 'import sys; print (sys.path)'
@@ -54,7 +54,7 @@ coverage report -m
 coverage html -d dist/tests/
 
 # Build documentation
-pip install -e .[doc]
+python3 -m pip install -e .[doc]
 pdoc3 --html --output-dir dist/ rok4
 
 # Build artefacts
diff --git a/rok4/Raster.py b/src/rok4/Raster.py
similarity index 53%
rename from rok4/Raster.py
rename to src/rok4/Raster.py
index 1fbb56c..ca8e006 100644
--- a/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -8,14 +8,20 @@
 
 import re
 import tempfile
+from enum import Enum
 
 from osgeo import ogr, gdal
 
-from rok4.Storage import get_data_str, exists, get_infos_from_path, copy, StorageType
+from rok4.Storage import exists, get_infos_from_path, copy, StorageType
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
+class ColorFormat(Enum):
+    BIT = 1
+    UINT8 = 8
+    FLOAT32 = 32
+
 
 class Raster():
     """A structure describing raster data
@@ -23,7 +29,8 @@ class Raster():
     Attributes :
         path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
         bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
-        samples (int): number of color channels
+        bands (int): number of color bands (or channels)
+        format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
         mask (str): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
     """
 
@@ -51,7 +58,7 @@ def __init__(self, path: str) -> None:
         else:
             tmp_image_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
             tmp_image_file.close()
-            work_image_path = tmp_image_file.name
+            work_image_path = tmp_image_file.name # utiliser Storage.get_osgeo_path(real_path) quand disponible
             copy(path, f"file://{work_image_path}")
 
         image_datasource = gdal.Open(work_image_path)
@@ -68,7 +75,7 @@ def __init__(self, path: str) -> None:
             else:
                 tmp_mask_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
                 tmp_mask_file.close()
-                work_mask_path = tmp_mask_file.name
+                work_mask_path = tmp_mask_file.name # utiliser Storage.get_osgeo_path(real_path) quand disponible
 
                 tmp_mask_file = None
                 copy(mask_path, f"file://{work_mask_path}") 
@@ -82,7 +89,20 @@ def __init__(self, path: str) -> None:
             self.mask = None
 
         self.bbox = _compute_bbox(image_datasource)
-        self.samples = image_datasource.RasterCount
+        self.bands = image_datasource.RasterCount
+        self.format = _compute_format(image_datasource, path)
+
+        # Pour l'obtenir sur un canal, deux méthodes (l'index du canal est compris entre 1 et RasterCount) :
+        # - gdal.GetDataTypeName(image_datasource.GetRasterBand(index).DataType)
+        # - gdal.GetDataTypeSize(image_datasource.GetRasterBand(index).DataType)
+        # La première solution donne le nom, par exemple "Byte" pour un entier 8 bits.
+        # La deuxième donne la taille en bits, "8" pour un entier 8 bits.
+        # Se base sur l'enum GDALDataType
+        # Les noms qui nous intéressent semblent être "Byte" pour "uint8", et "Float32" pour "float32".
+        # Comment faire pour les images 1 bit ? Il me faudrait un exemple de fichier.
+        # Exemple BDParcellaire fourni par Théo. tiffinfo détecte bien 1 canal 1 bit, mais gdal voit 1 canal 8 bits "Byte" avec palette 1 bit
+        # gdal.GetColorInterpretationName(ds.GetRasterBand(1).GetRasterColorInterpretation()) = Palette
+        # utiliser GetRasterColorInterpretation() et la fonction pour obtenir la compression ? (Celle-ci est "PACKBITS")
 
         tmp_image_file = None
 
@@ -126,3 +146,36 @@ def _compute_bbox(source_dataset: gdal.Dataset) -> tuple:
     return bbox
 
 
+def _compute_format(dataset: gdal.Dataset, path=None) -> ColorFormat:
+    """Image color format computing method
+
+    Args:
+        dataset (gdal.Dataset): Dataset object created from the raster image
+
+    Raises:
+        AttributeError: source_dataset is not a gdal.Dataset instance.
+        Exception: Image has no color band or its color format is unsupported.
+    """
+
+    format = None
+
+    if path is None:
+        path = dataset.GetFileList()[0]
+
+    if dataset.RasterCount < 1:
+        raise Exception(f"Image {path} contains no color band.")
+    
+    band_1_datatype = dataset.GetRasterBand(1).DataType
+    band_1_color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
+    compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
+
+    if gdal.GetDataTypeName(band_1_datatype) == "Byte" and gdal.GetDataTypeSize(band_1_datatype) == 8 and compression_regex_match and band_1_color_interpretation is not None and gdal.GetColorInterpretationName(band_1_color_interpretation) == "Palette":
+        format = ColorFormat.BIT
+    elif gdal.GetDataTypeName(band_1_datatype) == "Byte" and gdal.GetDataTypeSize(band_1_datatype) == 8:
+        format = ColorFormat.UINT8
+    elif gdal.GetDataTypeName(band_1_datatype) == "Float32" and gdal.GetDataTypeSize(band_1_datatype) == 32:
+        format = ColorFormat.FLOAT32
+    else:
+        raise Exception(f"Unsupported color format for image {path} : '{gdal.GetDataTypeName(band_1_datatype)}' ({gdal.GetDataTypeSize(band_1_datatype)} bits)")
+
+    return format
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index e4e196e..b122625 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,6 +1,6 @@
 """Describes unit tests for the rok4.Raster module."""
 
-from rok4.Raster import Raster, _compute_bbox
+from rok4.Raster import ColorFormat, Raster, _compute_bbox, _compute_format
 from rok4.Storage import StorageType
 
 from osgeo import gdal
@@ -8,7 +8,7 @@
 
 import pytest
 from unittest.mock import *
-from unittest import mock, TestCase, skip
+from unittest import mock, TestCase
 
 class TestConstructorCommon(TestCase):
     """Test class for the rok4.Raster.Raster(path) class constructor, for any storage type."""
@@ -54,11 +54,12 @@ def setUp(self):
         self.bbox = (-5.4, 41.3, 9.8, 51.3)
 
 
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
     @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path):
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_compute_format):
         """Test case : Constructor called nominally on an image without mask."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
@@ -75,15 +76,18 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
 
         mocked_compute_bbox.assert_called_once()
         assert raster_object.bbox == self.bbox
-        assert raster_object.samples == 3
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
 
 
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
     @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver):
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver, mocked_compute_format):
         """Test case : Constructor called nominally on an image with mask."""
 
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
@@ -103,7 +107,9 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_op
 
         mocked_compute_bbox.assert_called_once()
         assert raster_object.bbox == self.bbox
-        assert raster_object.samples == 3
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
 
 
     @mock.patch('rok4.Raster.get_infos_from_path')
@@ -173,13 +179,14 @@ def setUp(self):
         self.bbox = (-5.4, 41.3, 9.8, 51.3)
 
 
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
     @mock.patch('rok4.Raster.get_infos_from_path')
     @mock.patch('rok4.Raster.gdal.Open')
     @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_compute_format):
         """Test case : Constructor called nominally on an image without mask."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
@@ -201,9 +208,12 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
 
         mocked_compute_bbox.assert_called_once()
         assert raster_object.bbox == self.bbox
-        assert raster_object.samples == 3
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
 
 
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.copy')
     @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
@@ -211,7 +221,7 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
     @mock.patch('rok4.Raster.gdal.Open')
     @mock.patch('rok4.Raster._compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver):
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver, mocked_compute_format):
         """Test case : Constructor called nominally on an image with mask."""
         
         mocked_get_infos_from_path.return_value = self.get_infos_from_path
@@ -243,7 +253,9 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_op
 
         mocked_compute_bbox.assert_called_once()
         assert raster_object.bbox == self.bbox
-        assert raster_object.samples == 3
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
 
     
     @mock.patch('rok4.Raster.copy')
@@ -347,4 +359,134 @@ def test_nominal(self):
         assert expected == result
 
 
+class TestComputeFormat(TestCase):
+    """Test class for the rok4.Raster._compute_format function."""
+
+    def setUp(self) -> None:
+        self.bit_gdalinfo = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Image Structure Metadata:
+  COMPRESSION=PACKBITS
+  INTERLEAVE=BAND
+  MINISWHITE=YES
+"""
+        self.common_gdalinfo = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Metadata:
+  AREA_OR_POINT=Area
+Image Structure Metadata:
+  INTERLEAVE=BAND
+"""
+        return super().setUp()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName', return_value="Palette")
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=8)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Byte")
+    def test_bit(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        mocked_datasource.RasterCount = 1
+        mocked_Info.return_value = self.bit_gdalinfo
+
+        result = _compute_format(mocked_datasource)
+        assert result == ColorFormat.BIT
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=8)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Byte")
+    def test_uint8(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
+        
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = self.common_gdalinfo
+
+        result = _compute_format(mocked_datasource)
+
+        assert result == ColorFormat.UINT8
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_called()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=32)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Float32")
+    def test_float32(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
+        
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = self.common_gdalinfo
+
+        result = _compute_format(mocked_datasource)
+
+        assert result == ColorFormat.FLOAT32
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_called()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=16)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="UInt16")
+    def test_unsupported(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = self.common_gdalinfo
+
+        with pytest.raises(Exception):
+            _compute_format(mocked_datasource)
+        
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_called()
+
+    @mock.patch('rok4.Raster.gdal.Info')
+    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
+    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=16)
+    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="UInt16")
+    def test_no_band(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+        mocked_datasource = MagicMock(gdal.Dataset)
 
+        mocked_datasource.RasterCount = 0
+
+        with pytest.raises(Exception):
+            _compute_format(mocked_datasource)
+
+        mocked_GetDataTypeName.assert_not_called()
+        mocked_GetDataTypeSize.assert_not_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_not_called()
+
+
+    

From 55d88666a3e7f7711d9d0771ff666d410e4ca667 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Wed, 22 Mar 2023 09:52:01 +0100
Subject: [PATCH 12/89] =?UTF-8?q?Remplacement=20du=20constructeur=20par=20?=
 =?UTF-8?q?d=C3=A9faut=20de=20la=20classe=20Raster=20par=20deux=20m=C3=A9t?=
 =?UTF-8?q?hodes=20'from=5Ffile'=20et=20'from=5Fparameters'.=20Ajout=20d'u?=
 =?UTF-8?q?ne=20propri=C3=A9t=C3=A9=20'dimensions'=20(largeur=20et=20haute?=
 =?UTF-8?q?ur=20en=20pixel=20de=20l'image)=20=C3=A0=20la=20classe=20Raster?=
 =?UTF-8?q?.=20Ajout=20d'un=20prototype=20vide=20de=20fonction=20'get=5Fos?=
 =?UTF-8?q?geo=5Fpath'=20au=20module=20Storage,=20et=20utilisation=20de=20?=
 =?UTF-8?q?cette=20fonction=20par=20la=20classe=20raster=20pour=20d=C3=A9t?=
 =?UTF-8?q?erminer=20le=20chemin=20des=20fichiers=20locaux=20de=20travail.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |   1 +
 src/rok4/Raster.py   |  84 ++++----
 src/rok4/Storage.py  |   5 +
 tests/test_Raster.py | 463 +++++++++++++++----------------------------
 4 files changed, 207 insertions(+), 346 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e409281..bc13745 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,7 @@ Librairie de lecture d'une donnée raster.
 
 * Storage
     * La lecture d'un fichier ou objet qui n'existe pas émet toujours une exception `FileNotFoundError`
+    * Ajout d'un prototype vide de fonction 'get_osgeo_path', qui a terme, à partir d'un chemin complet vers une image, retournera le chemin système d'un fichier local de travail, créé si besoin.
 * Pyramid
     * Si la tuile que l'on veut lire est dans une dalle qui n'existe pas, on retourne `None`
 * README.md
diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index ca8e006..449db2c 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -12,7 +12,7 @@
 
 from osgeo import ogr, gdal
 
-from rok4.Storage import exists, get_infos_from_path, copy, StorageType
+from rok4.Storage import exists, get_infos_from_path, copy, StorageType, get_osgeo_path
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
@@ -32,34 +32,31 @@ class Raster():
         bands (int): number of color bands (or channels)
         format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
         mask (str): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
+        dimensions (Tuple[int, int]): image width and height expressed in pixels
     """
 
-    def __init__(self, path: str) -> None:
-        """Basic constructor method
+    @classmethod
+    def from_file(cls, path: str) -> 'Raster':
+        """Creates a Raster object from an image
 
         Args:
-            path (str): path to the file/object
+            path (str): path to the image file/object
 
         Raises:
             RuntimeError: raised by OGR/GDAL if anything goes wrong
             MissingEnvironmentError: Missing object storage informations
             StorageError: Storage read issue
+
+        Returns:
+            Raster: a Raster instance
         """
 
         if not exists(path):
             raise Exception(f"No file or object found at path '{path}'.")
 
-        image_info = get_infos_from_path(path)
+        self = cls()
 
-        tmp_image_file = None
-        work_image_path = None
-        if image_info[0] == StorageType.FILE:
-            work_image_path = image_info[1]
-        else:
-            tmp_image_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
-            tmp_image_file.close()
-            work_image_path = tmp_image_file.name # utiliser Storage.get_osgeo_path(real_path) quand disponible
-            copy(path, f"file://{work_image_path}")
+        work_image_path = get_osgeo_path(path)
 
         image_datasource = gdal.Open(work_image_path)
         self.path = path
@@ -67,19 +64,8 @@ def __init__(self, path: str) -> None:
         path_pattern = re.compile('(/[^/]+?)[.][a-zA-Z0-9_-]+$')
         mask_path = path_pattern.sub('\\1.msk', path)
 
-        tmp_mask_file = None
-        work_mask_path = None
-        if exists(mask_path):
-            if image_info[0] == StorageType.FILE:
-                work_mask_path = path_pattern.sub('\\1.msk', image_info[1])
-            else:
-                tmp_mask_file = tempfile.NamedTemporaryFile(mode='r', delete=False)
-                tmp_mask_file.close()
-                work_mask_path = tmp_mask_file.name # utiliser Storage.get_osgeo_path(real_path) quand disponible
-
-                tmp_mask_file = None
-                copy(mask_path, f"file://{work_mask_path}") 
-            
+        if exists(mask_path):            
+            work_mask_path = get_osgeo_path(mask_path)
             mask_driver = gdal.IdentifyDriver(work_mask_path).ShortName
             if 'GTiff' != mask_driver:
                 raise Exception(f"Mask file '{mask_path}' is not a TIFF image. (GDAL driver : '{mask_driver}'")
@@ -91,20 +77,39 @@ def __init__(self, path: str) -> None:
         self.bbox = _compute_bbox(image_datasource)
         self.bands = image_datasource.RasterCount
         self.format = _compute_format(image_datasource, path)
+        self.dimensions = (image_datasource.RasterXSize, image_datasource.RasterYSize)
+
+        return self
+
+    @classmethod
+    def from_parameters(cls, mask=None, **kwargs):
+        """Creates a Raster object from key/value parameters
+
+        Args:
+            **path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
+            **bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
+            **bands (int): number of color bands (or channels)
+            **format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
+            **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
+            **dimensions (Tuple[int, int]): image width and height expressed in pixels
+
+        Raises:
+            KeyError: a mandatory argument is missing
 
-        # Pour l'obtenir sur un canal, deux méthodes (l'index du canal est compris entre 1 et RasterCount) :
-        # - gdal.GetDataTypeName(image_datasource.GetRasterBand(index).DataType)
-        # - gdal.GetDataTypeSize(image_datasource.GetRasterBand(index).DataType)
-        # La première solution donne le nom, par exemple "Byte" pour un entier 8 bits.
-        # La deuxième donne la taille en bits, "8" pour un entier 8 bits.
-        # Se base sur l'enum GDALDataType
-        # Les noms qui nous intéressent semblent être "Byte" pour "uint8", et "Float32" pour "float32".
-        # Comment faire pour les images 1 bit ? Il me faudrait un exemple de fichier.
-        # Exemple BDParcellaire fourni par Théo. tiffinfo détecte bien 1 canal 1 bit, mais gdal voit 1 canal 8 bits "Byte" avec palette 1 bit
-        # gdal.GetColorInterpretationName(ds.GetRasterBand(1).GetRasterColorInterpretation()) = Palette
-        # utiliser GetRasterColorInterpretation() et la fonction pour obtenir la compression ? (Celle-ci est "PACKBITS")
+        Returns:
+            Raster: a Raster instance
+        """
+
+        self = cls()
+            
+        self.path = kwargs["path"]
+        self.mask = mask
+        self.bbox = kwargs["bbox"]
+        self.bands = kwargs["bands"]
+        self.format = kwargs["format"]
+        self.dimensions = kwargs["dimensions"]
 
-        tmp_image_file = None
+        return self
 
 
 def _compute_bbox(source_dataset: gdal.Dataset) -> tuple:
@@ -151,6 +156,7 @@ def _compute_format(dataset: gdal.Dataset, path=None) -> ColorFormat:
 
     Args:
         dataset (gdal.Dataset): Dataset object created from the raster image
+        path (str): path to the original file/object (optionnal)
 
     Raises:
         AttributeError: source_dataset is not a gdal.Dataset instance.
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index a10d1f8..9c2b2ac 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -830,3 +830,8 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
 
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to make link")
+
+def get_osgeo_path(path: str) -> str:
+    """Stud for a future function    
+    """
+    return None
\ No newline at end of file
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index b122625..70afbc1 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -8,313 +8,7 @@
 
 import pytest
 from unittest.mock import *
-from unittest import mock, TestCase
-
-class TestConstructorCommon(TestCase):
-    """Test class for the rok4.Raster.Raster(path) class constructor, for any storage type."""
-
-    def test_empty(self):
-        """Test case : Constructor called without the expected path argument."""
-
-        with pytest.raises(TypeError):
-            Raster()
-
-
-    @mock.patch('rok4.Raster.exists', return_value=False)
-    def test_image_not_found(self, mocked_exists):
-        """Test case : Constructor called on a path matching no file or object."""
-
-        path = "file:///home/user/image.tif"
-
-        with pytest.raises(Exception):
-            Raster(path)
-
-        mocked_exists.assert_called_once_with(path)
-
-
-
-class TestConstructorFile(TestCase):
-    """Test class for the rok4.Raster.Raster(path) class constructor, used with file storage."""
-
-    def setUp(self):
-        self.path = {
-            'protocol': 'file://',
-            'base_location': '/home/user',
-            'base_name': 'image',
-            'image': {},
-            'mask': {}
-        }
-        self.path['image']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.tif"
-        self.path['mask']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.msk"
-        self.path['image']['full'] = f"{self.path['protocol']}{self.path['image']['system']}"
-        self.path['mask']['full'] = f"{self.path['protocol']}{self.path['mask']['system']}"
-        
-        self.get_infos_from_path = (StorageType.FILE, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
-
-        self.bbox = (-5.4, 41.3, 9.8, 51.3)
-
-
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_compute_format):
-        """Test case : Constructor called nominally on an image without mask."""
-
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
-
-        raster_object = Raster( self.path['image']['full'] )
-
-        mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
-        mocked_get_infos_from_path.assert_called_once_with( self.path['image']['full'] )
-        mocked_gdal_open.assert_called_once_with( self.path['image']['system'] )
-        assert raster_object.path == self.path['image']['full']
-        assert raster_object.mask is None
-
-        mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-
-
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver, mocked_compute_format):
-        """Test case : Constructor called nominally on an image with mask."""
-
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
-
-        raster_object = Raster(self.path['image']['full'])
-
-        mocked_exists.assert_has_calls([ call(self.path['image']['full']), call(self.path['mask']['full']) ])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_identifydriver.assert_called_once_with(self.path['mask']['system'])
-        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
-        assert raster_object.path == self.path['image']['full']
-        assert raster_object.mask == self.path['mask']['full']
-
-        mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-
-
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path):
-        """Test case : Constructor called on an unsupported 'image' file or object."""
-
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-
-        with pytest.raises(RuntimeError):
-            Raster(self.path['image']['full'])
-
-        mocked_exists.assert_called_once_with(self.path['image']['full'])
-        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
-
-
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_identifydriver):
-        """Test case : Constructor called on an unsupported mask file or object."""
-
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
-
-        with pytest.raises(Exception):
-            Raster(self.path['image']['full'])      
-
-        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_identifydriver.assert_called_once_with(self.path['mask']['system'])
-        mocked_gdal_open.assert_called_once_with(self.path['image']['system'])
-
-
-
-class TestConstructorObject(TestCase):
-    """Test class for the rok4.Raster.Raster(path) class constructor, used with object storage."""
-
-    def setUp(self):
-        self.path = {
-            'protocol': 's3://',
-            'base_location': 'bucket',
-            'base_name': 'basename',
-            'image': {},
-            'mask': {}
-        }
-        self.path['image']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.tif"
-        self.path['mask']['system'] = f"{self.path['base_location']}/{self.path['base_name']}.msk"
-        self.path['image']['full'] = f"{self.path['protocol']}{self.path['image']['system']}"
-        self.path['mask']['full'] = f"{self.path['protocol']}{self.path['mask']['system']}"
-
-        self.get_infos_from_path = (StorageType.S3, self.path['image']['system'], self.path['base_location'], self.path['base_name'])
-
-        self.tmp_path = {
-            'image': {
-                'system': '/tmp/tempimage'
-            },
-            'mask': {
-                'system': '/tmp/tempmask'
-            },
-        }
-        self.tmp_path['image']['full'] = f"file://{self.tmp_path['image']['system']}"
-        self.tmp_path['mask']['full'] = f"file://{self.tmp_path['mask']['system']}"
-
-        self.bbox = (-5.4, 41.3, 9.8, 51.3)
-
-
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.copy')
-    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_compute_format):
-        """Test case : Constructor called nominally on an image without mask."""
-        
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_tmp_file_close = Mock()
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
-        # This next line emulates the return of tempfile.NamedTemporaryFile()
-        mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
-
-        raster_object = Raster(self.path['image']['full'])
-
-        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_create_temporary_file.assert_called_once_with(mode='r', delete=False)
-        mocked_copy.assert_called_once_with(self.path['image']['full'], self.tmp_path['image']['full'])
-        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
-        assert raster_object.path == self.path['image']['full']
-        assert raster_object.mask is None
-
-        mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-
-
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.copy')
-    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver, mocked_compute_format):
-        """Test case : Constructor called nominally on an image with mask."""
-        
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_tmp_file_close = Mock()
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3})
-        # This next instruction emulates the return of tempfile.NamedTemporaryFile()
-        mocked_create_temporary_file.side_effect = [
-            type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
-            type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
-        ]
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
-
-        raster_object = Raster(self.path['image']['full'])
-
-        expected_copy_calls = [
-            call(self.path['image']['full'], self.tmp_path['image']['full']),
-            call(self.path['mask']['full'], self.tmp_path['mask']['full'])
-        ]
-        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
-        mocked_copy.assert_has_calls(expected_copy_calls)
-        mocked_identifydriver.assert_called_once_with(self.tmp_path['mask']['system'])
-        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
-        assert raster_object.path == self.path['image']['full']
-        assert raster_object.mask == self.path['mask']['full']
-
-        mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-
-    
-    @mock.patch('rok4.Raster.copy')
-    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy):
-        """Test case : Constructor called on an unsupported 'image' file or object."""
-        
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_tmp_file_close = Mock()
-        # This next line emulates the return of tempfile.NamedTemporaryFile()
-        mocked_create_temporary_file.return_value = type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close})
-
-        with pytest.raises(RuntimeError):
-            Raster(self.path['image']['full'])
-
-        mocked_exists.assert_called_once_with(self.path['image']['full'])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_create_temporary_file.assert_called_once_with(mode='r', delete=False)
-        mocked_copy.assert_called_once_with(self.path['image']['full'], self.tmp_path['image']['full'])
-        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
-
-
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.copy')
-    @mock.patch('rok4.Raster.tempfile.NamedTemporaryFile')
-    @mock.patch('rok4.Raster.get_infos_from_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_get_infos_from_path, mocked_create_temporary_file, mocked_copy, mocked_identifydriver):
-        """Test case : Constructor called on an unsupported mask file or object."""
-        
-        mocked_get_infos_from_path.return_value = self.get_infos_from_path
-        mocked_tmp_file_close = Mock()
-        # This next instruction emulates the return of tempfile.NamedTemporaryFile()
-        mocked_create_temporary_file.side_effect = [
-            type('', (object,), {'name': self.tmp_path['image']['system'], 'close': mocked_tmp_file_close}),
-            type('', (object,), {'name': self.tmp_path['mask']['system'], 'close': mocked_tmp_file_close})
-        ]
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
-
-        with pytest.raises(Exception):
-            Raster(self.path['image']['full'])
-
-        expected_copy_calls = [
-            call(self.path['image']['full'], self.tmp_path['image']['full']),
-            call(self.path['mask']['full'], self.tmp_path['mask']['full'])
-        ]
-        mocked_exists.assert_has_calls([call(self.path['image']['full']), call(self.path['mask']['full'])])
-        mocked_get_infos_from_path.assert_called_once_with(self.path['image']['full'])
-        mocked_create_temporary_file.assert_has_calls([call(mode='r', delete=False), call(mode='r', delete=False)])
-        mocked_copy.assert_has_calls(expected_copy_calls)
-        mocked_identifydriver.assert_called_once_with(self.tmp_path['mask']['system'])
-        mocked_gdal_open.assert_called_once_with(self.tmp_path['image']['system'])
-
-
+from unittest import mock, TestCase, skip
 
 class TestComputeBbox(TestCase):
     """Test class for the rok4.Raster._compute_bbox function."""
@@ -489,4 +183,159 @@ def test_no_band(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_Ge
         mocked_Info.assert_not_called()
 
 
+class TestFromFile(TestCase):
+    """Test class for the rok4.Raster.Raster.from_file(path) class constructor."""
+
+    def setUp(self):
+        self.source_image_path = "file:///home/user/image.tif"
+        self.source_mask_path = "file:///home/user/image.msk"
+        self.osgeo_image_path = "file:///home/user/image.tif"
+        self.osgeo_mask_path = "file:///home/user/image.msk"
+        self.bbox = (-5.4, 41.3, 9.8, 51.3)
+        self.image_size = (1920, 1080)
+        return super().setUp()
+
+    def test_empty(self):
+        """Test case : Constructor called without the expected path argument."""
+
+        with pytest.raises(TypeError):
+            Raster.from_file()
+
+    @mock.patch('rok4.Raster.exists', return_value=False)
+    def test_image_not_found(self, mocked_exists):
+        """Test case : Constructor called on a path matching no file or object."""
+
+        with pytest.raises(Exception):
+            Raster.from_file(self.source_image_path)
+
+        mocked_exists.assert_called_once_with(self.source_image_path)
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_bbox')
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_compute_format, mocked_get_osgeo_path):
+        """Test case : Constructor called nominally on an image without mask."""
+
+        mocked_compute_bbox.return_value = self.bbox
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3, 'RasterXSize': self.image_size[0], 'RasterYSize': self.image_size[1]})
+        mocked_get_osgeo_path.return_value = self.osgeo_image_path
+
+        raster_object = Raster.from_file( self.source_image_path )
+
+        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_get_osgeo_path.assert_called_once_with(self.source_image_path)
+        mocked_gdal_open.assert_called_once_with( self.osgeo_image_path )
+        assert raster_object.path == self.source_image_path
+        assert raster_object.mask is None
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == self.bbox
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
+        assert raster_object.dimensions == self.image_size
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
+    @mock.patch('rok4.Raster.gdal.Open')
+    @mock.patch('rok4.Raster._compute_bbox')
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_identifydriver, mocked_compute_format, mocked_get_osgeo_path):
+        """Test case : Constructor called nominally on an image with mask."""
+
+        mocked_compute_bbox.return_value = self.bbox
+        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3, 'RasterXSize': self.image_size[0], 'RasterYSize': self.image_size[1]})
+        mocked_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
+
+        raster_object = Raster.from_file(self.source_image_path)
+
+        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_get_osgeo_path.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_identifydriver.assert_called_once_with(self.osgeo_mask_path)
+        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
+        assert raster_object.path == self.source_image_path
+        assert raster_object.mask == self.source_mask_path
+
+        mocked_compute_bbox.assert_called_once()
+        assert raster_object.bbox == self.bbox
+        assert raster_object.bands == 3
+        mocked_compute_format.assert_called_once()
+        assert raster_object.format == ColorFormat.UINT8
+        assert raster_object.dimensions == self.image_size
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
+    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
+    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_osgeo_path):
+        """Test case : Constructor called on an unsupported 'image' file or object."""
+
+        mocked_get_osgeo_path.return_value = self.osgeo_image_path
+
+        with pytest.raises(RuntimeError):
+            Raster.from_file(self.source_image_path)
+
+        mocked_exists.assert_called_once_with(self.source_image_path)
+        mocked_get_osgeo_path.assert_called_once_with(self.source_image_path)
+        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
+    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
+    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_identifydriver, mocked_get_osgeo_path):
+        """Test case : Constructor called on an unsupported mask file or object."""
+
+        mocked_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
+        # This next line emulates the return of gdal.IdentifyDriver()
+        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
+
+        with pytest.raises(Exception):
+            Raster.from_file(self.source_image_path)      
+
+        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_get_osgeo_path.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_identifydriver.assert_called_once_with(self.osgeo_mask_path)
+        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
+
+
+class TestFromParameters(TestCase):
+    """Test class for the rok4.Raster.Raster.from_parameters(**kwargs) class constructor."""
+
+    def test_image(self):
+        i_path = "file:///path/to/image.tif"
+        i_bbox = (-5.4, 41.3, 9.8, 51.3)
+        i_bands = 4
+        i_format = ColorFormat.UINT8
+        i_dimensions = (1920, 1080)
+
+        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions)
+
+        assert result.path == i_path
+        assert result.bbox == i_bbox
+        assert result.bands == i_bands
+        assert result.format == i_format
+        assert result.dimensions == i_dimensions
+        assert result.mask is None
+
+    def test_image_and_mask(self):
+        i_path = "file:///path/to/image.tif"
+        i_mask = "file:///path/to/image.msk"
+        i_bbox = (-5.4, 41.3, 9.8, 51.3)
+        i_bands = 4
+        i_format = ColorFormat.UINT8
+        i_dimensions = (1920, 1080)
+
+        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions, mask=i_mask)
+
+        assert result.path == i_path
+        assert result.bbox == i_bbox
+        assert result.bands == i_bands
+        assert result.format == i_format
+        assert result.dimensions == i_dimensions
+        assert result.mask == i_mask
     

From 57b759bf827871c908b656963b622bb38064e480 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Thu, 23 Mar 2023 15:39:00 +0100
Subject: [PATCH 13/89] Ajout de fonction de lecture de la liste d'une pyramide

---
 CHANGELOG.md                     |  22 +--
 README.md                        |   6 +-
 README.pypi.md                   |   8 +-
 src/rok4/Pyramid.py              | 294 ++++++++++++++++++++++++++++++-
 src/rok4/Storage.py              |   2 +-
 tests/fixtures/TIFF_PBF_MVT.list |   3 +
 tests/test_Pyramid.py            |  36 +++-
 tests/test_Storage.py            |   2 +-
 8 files changed, 341 insertions(+), 32 deletions(-)
 create mode 100644 tests/fixtures/TIFF_PBF_MVT.list

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8dd332d..0a24c5b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,28 +1,20 @@
 ## Summary
 
-Lecture par système de fichier virtuel avec GDAL
+Lecture facilitée de la liste d'une pyramide.
 
 ## Changelog
 
 ### [Added]
 
-* Storage
-    * Fonction `get_osgeo_path` permettant de configurer le bon sytème de fichier virtuel en fonction du chemin fourni, et retourne celui à utiliser dans le Open de gdal ou ogr
-
-### [Changed]
-
-* Storage
-    * la récupération d'un client S3 (`__get_s3_client`) permet de récupérer le client, l'hôte, les clés d'accès et secrète, ainsi que le nom du bucket sans l'éventuel hôte du cluster
-
+* 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]
 
 * Storage
-    * Lecture binaire S3 : mauvaise configuration du nom du bucket et de l'objet et mauvaise lecture partielle
-
-### [Removed]
-
-* Exceptions
-    * `NotImplementedError` est une exceptions native
+    * Lecture de la taille d'un objet S3 : pas besoin d'enlever des quotes dans le header `Content-Length`
 <!--
 ### [Added]
 
diff --git a/README.md b/README.md
index 191feab..a75c02f 100644
--- a/README.md
+++ b/README.md
@@ -25,17 +25,15 @@ L'environnement d'exécution doit avoir accès aux librairies système. Dans le
 
 ```python
 from rok4.TileMatrixSet import TileMatrixSet
-from rok4.Vector import Vector
 
 try:
     tms = TileMatrixSet("file:///path/to/tms.json")
-    vector = Vector("file:///path/to/vector.shp")
-    vector_csv1 = Vector("file:///path/to/vector.csv", delimiter, column_x, column_y)
-    vector_csv1 = Vector("file:///path/to/vector.csv", delimiter, column_WKT)
 except Exception as exc:
     print(exc)
 ```
 
+Plus d'exemple dans la documentation développeur.
+
 ## Compiler la librairie
 
 ```sh
diff --git a/README.pypi.md b/README.pypi.md
index b5184c3..1f0bf75 100644
--- a/README.pypi.md
+++ b/README.pypi.md
@@ -17,13 +17,11 @@ The `rok4` package is available on :
 
 ```python
 from rok4.TileMatrixSet import TileMatrixSet
-from rok4.Vector import Vector
 
 try:
     tms = TileMatrixSet("file:///path/to/tms.json")
-    vector = Vector("file:///path/to/vector.shp")
-    vector_csv1 = Vector("file:///path/to/vector.csv", delimiter, column_x, column_y)
-    vector_csv1 = Vector("file:///path/to/vector.csv", delimiter, column_WKT)
 except Exception as exc:
     print(exc)
-```
\ No newline at end of file
+```
+
+More examples in the developer documentation
\ No newline at end of file
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 1956584..bc9e669 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -6,7 +6,7 @@
 - `Level` - Level of a pyramid
 """
 
-from typing import Dict, List, Tuple, Union
+from typing import Dict, List, Tuple, Union, Iterator
 import json
 from json.decoder import JSONDecodeError
 import os
@@ -23,12 +23,19 @@
 from rok4.Utils import *
 
 class PyramidType(Enum):
+    """ Pyramid's data type """
     RASTER = "RASTER"
     VECTOR = "VECTOR"
 
+
 class SlabType(Enum):
-    DATA = "DATA"
-    MASK = "MASK"
+    """ Slab's type """
+    DATA = "DATA" # Slab of data, raster or vector
+    MASK = "MASK" # Slab of mask, only for raster pyramide, image with one band : 0 is nodata, other values are data
+
+
+ROK4_IMAGE_HEADER_SIZE = 2048
+"""Slab's header size, 2048 bytes"""
 
 def b36_number_encode(number: int) -> str:
     """Convert base-10 number to base-36
@@ -343,6 +350,21 @@ 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). 
+
+            Example (S3 storage): 
+
+                {
+                    'cache': {
+                        (<SlabType.DATA: 'DATA'>, '18', 5424, 7526): {
+                            'link': False,
+                            'md5': None,
+                            'root': 'pyramids@localhost:9000/LIMADM',
+                            'slab': 'DATA_18_5424_7526'
+                        }
+                    },
+                    'loaded': True
+                }
     """
 
     @classmethod
@@ -359,6 +381,17 @@ def from_descriptor(cls, descriptor: str) -> 'Pyramid':
             StorageError: Storage read issue (pyramid descriptor or TMS)
             MissingEnvironmentError: Missing object storage informations or TMS root directory
 
+        Examples:
+
+            S3 stored descriptor
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor")
+
         Returns:
             Pyramid: a Pyramid instance
         """        
@@ -469,6 +502,11 @@ def __init__(self) -> None:
         self.__levels = dict()
         self.__masks = None
 
+        self.__content = {
+            "loaded": False,
+            "cache": dict()
+        }
+
     def __str__(self) -> str:
         return f"{self.type.name} pyramid '{self.__name}' ({self.__storage['type'].name} storage)"
 
@@ -594,6 +632,19 @@ def own_masks(self) -> bool:
     def format(self) -> str: 
         return self.__format
 
+    @property
+    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"]:
+            return "jpg"
+        elif self.__format == "TIFF_PNG_UINT8":
+            return "png"
+        elif self.__format == "TIFF_PBF_MVT":
+            return "pbf"
+        else:
+            raise Exception(f"Unknown pyramid's format ({self.__format}), cannot return the tile extension")
+
     @property
     def bottom_level(self) -> 'Level': 
         """Get the best resolution level in the pyramid
@@ -624,6 +675,111 @@ def type(self) -> PyramidType:
         else:
             return PyramidType.RASTER
 
+    def load_list(self) -> None:
+        """Load list content and cache it
+
+        If list is already loaded, nothing done
+        """        
+        if self.__content["loaded"]:
+            return
+
+        for slab, infos in self.list_generator():
+            self.__content["cache"][slab] = infos
+
+        self.__content["loaded"] = True
+
+    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
+
+        Examples:
+
+            S3 stored descriptor
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+
+                    for (slab_type, level, column, row), infos in pyramid.list_generator():
+                        print(infos)
+
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and read the list")
+
+        Yields:
+            Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]: Slab indices and storage informations
+
+            Value example:
+
+                ( 
+                    (<SlabType.DATA: 'DATA'>, '18', 5424, 7526),
+                    {
+                        'link': False,
+                        'md5': None,
+                        'root': 'pyramids@localhost:9000/LIMADM',
+                        'slab': 'DATA_18_5424_7526'
+                    }
+                )
+
+        """        
+        if self.__content["loaded"]:
+            for slab, infos in self.__content["cache"].items():
+                yield slab, infos
+        else:
+
+            # Copie de la liste dans un fichier temporaire (cette liste peut être un objet)
+            list_obj = tempfile.NamedTemporaryFile(mode='r', delete=False)
+            list_file = list_obj.name
+            copy(self.__list, f"file://{list_file}")
+            list_obj.close()
+
+            roots = dict()
+            s3_cluster = self.storage_s3_cluster
+
+            with open(list_file, "r") as listin:
+
+                # Lecture des racines
+                for line in listin:
+                    line = line.rstrip()
+                    
+                    if line == "#":
+                        break
+
+                    root_id, root_path = line.split("=", 1)
+
+                    if s3_cluster is None:
+                        roots[root_id] = root_path
+                    else:
+                        # On a un nom de cluster S3, on l'ajoute au nom du bucket dans les racines
+                        root_bucket, root_path = root_path.split("/", 1)
+                        roots[root_id] = f"{root_bucket}@{s3_cluster}/{root_path}"
+
+                # Lecture des dalles
+                for line in listin:
+                    line = line.rstrip()
+
+                    parts = line.split(" ", 1)
+                    slab_path = parts[0]
+                    slab_md5 = None
+                    if len(parts) == 2:
+                        slab_md5 = parts[1]
+
+                    root_id, slab_path = slab_path.split("/", 1)
+
+                    slab_type, level, column, row = self.get_infos_from_slab_path(slab_path)
+                    infos = {
+                        "root": roots[root_id],
+                        "link": root_id != '0',
+                        "slab": slab_path,
+                        "md5": slab_md5
+                    }
+
+                    yield ((slab_type,level,column,row), infos)
+
+            remove(f"file://{list_file}")
+
     def get_level(self, level_id: str) -> 'Level':
         """Get one level according to its identifier
 
@@ -638,7 +794,7 @@ def get_level(self, level_id: str) -> 'Level':
 
 
     def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
-        """Get sorted levels from bottom and top provided
+        """Get sorted levels from bottom to top provided
 
         Args:
             bottom_id (str): optionnal specific bottom level id. Defaults to None.
@@ -647,6 +803,30 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
         Raises:
             Exception: Provided levels are not consistent (bottom > top or not in the pyramid)
 
+        Examples:
+
+            All levels
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+                    levels = pyramid.get_levels()
+
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and get levels")
+
+            From pyramid's bottom to provided top (level 5)
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+                    levels = pyramid.get_levels(None, "5")
+
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and get levels")
+
         Returns:
             List[Level]: asked sorted levels
         """
@@ -701,6 +881,30 @@ def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
         Args:
             path (str): Slab's storage path
 
+        Examples:
+
+            FILE stored pyramid
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("/path/to/descriptor.json")
+                    slab_type, level, column, row = self.get_infos_from_slab_path("DATA/12/00/4A/F7.tif")
+                    # (SlabType.DATA, "12", 159, 367)
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and convert a slab path")
+
+            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")
+                    # (SlabType.MASK, "15", 9164, 5846)
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and convert a slab path")
+
         Returns:
             Tuple[SlabType, str, int, int]: Slab's type (DATA or MASK), level identifier, slab's column and slab's row
         """        
@@ -777,6 +981,28 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         Limitations:
             Pyramids with one-tile slab are not handled
 
+        Examples:
+
+            FILE stored raster pyramid, to extract a tile containing a point and save it as independent image
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("/data/pyramids/SCAN1000.json")
+                    level, col, row, pcol, prow = pyramid.get_tile_indices(992904.46, 6733643.15, "9", srs = "IGNF:LAMB93")
+                    data = pyramid.get_tile_data_binary(level, col, row)
+
+                    if data is None:
+                        print("No data")
+                    else:
+                        tile_name = f"tile_{level}_{col}_{row}.{pyramid.tile_extension}"
+                        with open(tile_name, "wb") as image:
+                            image.write(data)
+                        print (f"Tile written in {tile_name}")
+
+                except Exception as e:
+                    print("Cannot save a pyramid's tile : {e}")
+
         Raises:
             Exception: Level not found in the pyramid
             NotImplementedError: Pyramid owns one-tile slabs
@@ -817,7 +1043,7 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         # puis sont stockés les offsets (chacun sur 4 octets)
         # puis les tailles (chacune sur 4 octets)
         try:
-            binary_index = get_data_binary(slab_path, (2048, 2 * 4 * level_object.slab_width * level_object.slab_height))
+            binary_index = get_data_binary(slab_path, (ROK4_IMAGE_HEADER_SIZE, 2 * 4 * level_object.slab_width * level_object.slab_height))
         except FileNotFoundError as e:
             # L'absence de la dalle est gérée comme simplement une absence de données
             return None
@@ -861,6 +1087,25 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
             StorageError: Storage read issue
             FormatError: Cannot decode tile
 
+        Examples:
+
+            FILE stored DTM (raster) pyramid, to get the altitude value at a point in the best level
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("/data/pyramids/RGEALTI.json")
+                    level, col, row, pcol, prow = pyramid.get_tile_indices(44, 5, srs = "EPSG:4326")
+                    data = pyramid.get_tile_data_raster(level, col, row)
+
+                    if data is None:
+                        print("No data")
+                    else:
+                        print(data[prow][pcol])
+
+                except Exception as e:
+                    print("Cannot get a pyramid's pixel value : {e}")
+
         Returns:
             str: data, as numpy array, None if no data
         """
@@ -951,6 +1196,26 @@ def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
             StorageError: Storage read issue
             FormatError: Cannot decode tile
 
+        Examples:
+
+            S3 stored vector pyramid, to print a tile as GeoJSON
+
+                from rok4.Pyramid import Pyramid
+                import json
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://pyramids/vectors/BDTOPO.json")
+                    level, col, row, pcol, prow = pyramid.get_tile_indices(40.325, 3.123, srs = "EPSG:4326")
+                    data = pyramid.get_tile_data_vector(level, col, row)
+
+                    if data is None:
+                        print("No data")
+                    else:
+                        print(json.dumps(data))
+
+                except Exception as e:
+                    print("Cannot print a vector pyramid's tile as GeoJSON : {e}")
+
         Returns:
             str: data, as GeoJSON dictionnary. None if no data
         """
@@ -990,6 +1255,25 @@ def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> T
             Exception: Cannot find level to calculate indices
             RuntimeError: Provided SRS is invalid for OSR
 
+        Examples:
+
+            FILE stored DTM (raster) pyramid, to get the altitude value at a point in the best level
+
+                from rok4.Pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("/data/pyramids/RGEALTI.json")
+                    level, col, row, pcol, prow = pyramid.get_tile_indices(44, 5, srs = "EPSG:4326")
+                    data = pyramid.get_tile_data_raster(level, col, row)
+
+                    if data is None:
+                        print("No data")
+                    else:
+                        print(data[prow][pcol])
+
+                except Exception as e:
+                    print("Cannot get a pyramid's pixel value : {e}")
+
         Returns:
             Tuple[str, int, int, int, int]: Level identifier, tile's column, tile's row, pixel's (in the tile) column, pixel's row
         """
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index b0ced08..dc19b80 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -413,7 +413,7 @@ def get_size(path: str) -> int:
         s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            size = s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)["ContentLength"].strip('"')
+            size = s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)["ContentLength"]
             return int(size)
         except Exception as e:
             raise StorageError("S3", e)
diff --git a/tests/fixtures/TIFF_PBF_MVT.list b/tests/fixtures/TIFF_PBF_MVT.list
new file mode 100644
index 0000000..1c66e00
--- /dev/null
+++ b/tests/fixtures/TIFF_PBF_MVT.list
@@ -0,0 +1,3 @@
+0=TIFF_PBF_MVT
+#
+0/DATA/4/00/00/21.tif
\ No newline at end of file
diff --git a/tests/test_Pyramid.py b/tests/test_Pyramid.py
index 7a888a6..065e0b8 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_Pyramid.py
@@ -116,9 +116,10 @@ def test_raster_ok(mocked_put_data_str, mocked_tms_class, mocked_get_data_str):
         assert clone.name == "titi"
         assert clone.storage_type == StorageType.FILE
         assert clone.storage_root == "/data/ign"
+        assert clone.tile_extension == "jpg"
         assert clone.get_level("0") is not None
         assert clone.get_level("4") is None
-        assert clone.get_infos_from_slab_path("IMAGE/12/00/00/00.tif") == (SlabType.DATA, "12", 0, 0)
+        assert clone.get_infos_from_slab_path("/data/ign/titi/IMAGE/12/00/4A/F7.tif") == (SlabType.DATA, "12", 159, 367)
         assert clone.get_tile_indices(102458, 6548125, srs = "EPSG:3857") == ("0",0,0,128,157)
         assert clone.get_tile_indices(43, 2, srs = "EPSG:4326") == ("0",0,0,128,157)
 
@@ -146,6 +147,7 @@ def test_vector_ok(mocked_tms_class, mocked_get_data_str):
 
         clone = Pyramid.from_other(pyramid, "toto", {"type": "S3", "root": "bucket"})
         assert clone.name == "toto"
+        assert clone.tile_extension == "pbf"
         assert clone.storage_type == StorageType.S3
         assert clone.get_level("0") is not None
         assert clone.get_level("4") is None
@@ -211,6 +213,38 @@ def test_tile_read_vector(mocked_tms_class):
     except Exception as exc:
         assert False, f"Pyramid vector tile read raises an exception: {exc}"
 
+
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch('rok4.Pyramid.TileMatrixSet')
+def test_list_read(mocked_tms_class):
+
+    tms_instance = MagicMock()
+    tms_instance.name = "PM"
+    tms_instance.srs = "EPSG:3857"
+    
+    tm_instance = MagicMock()
+    tm_instance.id = "4"
+    tm_instance.tile_size = (256,256)
+
+    tms_instance.get_level.return_value = tm_instance
+
+    mocked_tms_class.return_value = tms_instance
+
+    try:
+        pyramid = Pyramid.from_descriptor("file://tests/fixtures/TIFF_PBF_MVT.json")
+        pyramid.load_list()
+        pyramid.load_list() # on passe par la détection d'une liste déjà chrargée ainsi
+        for (slab_type, level, column, row), infos in pyramid.list_generator():
+            assert slab_type == SlabType.DATA
+            assert level == '4'
+            assert column == 2
+            assert row == 1
+            assert infos == {'link': False, 'md5': None, 'root': 'TIFF_PBF_MVT', 'slab': 'DATA/4/00/00/21.tif'}
+
+    except Exception as exc:
+        assert False, f"Pyramid vector list read raises an exception: {exc}"
+
+
 def test_b36_path_decode():
     assert b36_path_decode("3E/42/01.tif") == (4032, 18217,)
     assert b36_path_decode("3E/42/01.TIFF") == (4032, 18217,)
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 40cb365..34a5c37 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -478,7 +478,7 @@ def test_size_s3_ok(mocked_s3_client):
 
     disconnect_s3_clients()
     s3_instance = MagicMock()
-    s3_instance.head_object.return_value = {"ContentLength": '"12"'}
+    s3_instance.head_object.return_value = {"ContentLength": 12}
     mocked_s3_client.return_value = s3_instance
 
     try:

From 569b785e7344ba56bb4b1a98fef7d3d163f47b82 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Thu, 30 Mar 2023 14:52:33 +0200
Subject: [PATCH 14/89] Merge branch 'develop' of
 https://github.com/rok4/core-python into feature/stockage_HTTP

---
 .github/workflows/build-and-release.yaml |  11 +-
 CHANGELOG.md                             |  18 ++-
 README.md                                |   3 +
 src/rok4/Exceptions.py                   |   8 --
 src/rok4/Storage.py                      | 161 ++++++++++++++---------
 tests/test_Storage.py                    |  32 ++++-
 tests/test_Utils.py                      |   6 +-
 7 files changed, 162 insertions(+), 77 deletions(-)

diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 2802b78..40fb13e 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -73,7 +73,7 @@ jobs:
           echo "/usr/lib/python3/dist-packages/" >.venv/lib/python${{ matrix.python-version }}/site-packages/system.pth
 
       - name: Run unit tests
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           pip install -e .[test]
@@ -81,20 +81,20 @@ jobs:
           coverage report -m
 
       - name: Build unit tests report
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           coverage html -d dist/tests/
           rm dist/tests/.gitignore
 
       - name: Build package
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           python3 -m build
 
       - name: Build documentation
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           pip install -e .[doc]
@@ -102,7 +102,7 @@ jobs:
           cp README.md CHANGELOG.md dist/
 
       - name: Upload packages, tests results and documentation
-        if: "(${{ matrix.os }}=='ubuntu-20.04')&&(${{ matrix.python-version }}=='3.8')"
+        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         uses: actions/upload-artifact@v3
         with:
           name: dist-py3
@@ -189,6 +189,7 @@ jobs:
           cat artifact/CHANGELOG.md >>docs/versions/${{ github.ref_name }}/CHANGELOG.md
           sed "s#__version__#${{ github.ref_name }}#" templates/README.template.md >docs/versions/${{ github.ref_name }}/README.md
           cat artifact/README.md >>docs/versions/${{ github.ref_name }}/README.md
+          sed -i "s#x.y.z#${{ github.ref_name }}#g" docs/versions/${{ github.ref_name }}/README.md
           sed "s#__version__#${{ github.ref_name }}#" templates/index.template.md >docs/index.md
           echo "# Versions" >docs/versions.md
           echo "" >>docs/versions.md
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 256187b..6df50cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,15 +1,31 @@
 ## Summary
 
 Ajout du type de stockage HTTP.
+Lecture par système de fichier virtuel avec GDAL
 
 ## Changelog
 
 ### [Added]
 
-* Storage :
+* Storage
+    * Fonction `get_osgeo_path` permettant de configurer le bon sytème de fichier virtuel en fonction du chemin fourni, et retourne celui à utiliser dans le Open de gdal ou ogr
+
+### [Changed]
+
+* Storage
+    * la récupération d'un client S3 (`__get_s3_client`) permet de récupérer le client, l'hôte, les clés d'accès et secrète, ainsi que le nom du bucket sans l'éventuel hôte du cluster
     * Ajout de la copie de HTTP vers FILE/S3/CEPH
     * Ajout de la fonction de lecture d'un fichier HTTP, de l'existence d'un fichier HTTP et du calcul de taille d'un fichier HTTP
 
+### [Fixed]
+
+* Storage
+    * Lecture binaire S3 : mauvaise configuration du nom du bucket et de l'objet et mauvaise lecture partielle
+
+### [Removed]
+
+* Exceptions
+    * `NotImplementedError` est une exceptions native
 <!--
 ### [Added]
 
diff --git a/README.md b/README.md
index 400645d..191feab 100644
--- a/README.md
+++ b/README.md
@@ -16,8 +16,11 @@ Installations système requises :
 * debian : `apt install python3-rados python3-gdal`
 
 Depuis [PyPI](https://pypi.org/project/rok4/) : `pip install rok4`
+
 Depuis [GitHub](https://github.com/rok4/core-python/releases/) : `pip install https://github.com/rok4/core-python/releases/download/x.y.z/rok4-x.y.z-py3-none-any.whl`
 
+L'environnement d'exécution doit avoir accès aux librairies système. Dans le cas d'une utilisation au sein d'un environnement python, précisez bien à la création `python3 -m venv --system-site-packages .venv`.
+
 ## Utiliser la librairie
 
 ```python
diff --git a/src/rok4/Exceptions.py b/src/rok4/Exceptions.py
index 3f0ff4f..92c75e3 100644
--- a/src/rok4/Exceptions.py
+++ b/src/rok4/Exceptions.py
@@ -37,11 +37,3 @@ def __init__(self, expected_format, content, issue):
         self.content = content
         self.issue = issue
         super().__init__(f"Expected format {expected_format} to read '{content}' : {issue}")
-
-class NotImplementedError(Exception):
-    """
-    Exception raised when a feature could be provided but is not implemented yet
-    """
-
-    def __init__(self, issue):
-        super().__init__(issue)
\ No newline at end of file
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index 1db35e9..af95c85 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -38,9 +38,12 @@
 import rados
 import hashlib
 import requests
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Union
 from enum import Enum
 from shutil import copyfile
+from osgeo import gdal
+
+gdal.UseExceptions()
 
 from rok4.Exceptions import *
 
@@ -53,7 +56,7 @@ class StorageType(Enum):
 
 __S3_CLIENTS = dict()
 __S3_DEFAULT_CLIENT = None
-def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
+def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',str]], str, str]:
     """Get the S3 client
 
     Create it if not already done
@@ -66,7 +69,7 @@ def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
         StorageError: S3 client configuration issue
 
     Returns:
-        Tuple['boto3.client', str, str]: the S3 client, the cluster host and the simple bucket name
+        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
 
@@ -84,15 +87,21 @@ def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
 
                 h = re.sub("https?://", "", urls[i])
 
-                if urls[i] in __S3_CLIENTS:
+                if h in __S3_CLIENTS:
                     raise StorageError("S3", "A S3 cluster is defined twice (based on URL)")
 
-                __S3_CLIENTS[h] = boto3.client(
-                    's3',
-                    aws_access_key_id = keys[i],
-                    aws_secret_access_key = secret_keys[i],
-                    endpoint_url = urls[i]
-                )
+                __S3_CLIENTS[h] = {
+                    "client": boto3.client(
+                        's3',
+                        aws_access_key_id = keys[i],
+                        aws_secret_access_key = secret_keys[i],
+                        endpoint_url = urls[i]
+                    ),
+                    "key": keys[i],
+                    "secret_key": secret_keys[i],
+                    "url": urls[i],
+                    "host": h
+                }
 
                 if i == 0:
                     # Le premier cluster est celui par défaut
@@ -114,7 +123,7 @@ def __get_s3_client(bucket_name: str) -> Tuple['boto3.client', str, str]:
     if host not in __S3_CLIENTS:
         raise StorageError("S3", f"Unknown S3 cluster, according to host '{host}'")
 
-    return __S3_CLIENTS[host], host, bucket_name
+    return __S3_CLIENTS[host], bucket_name
 
 def disconnect_s3_clients() -> None:
     """Clean S3 clients
@@ -277,19 +286,19 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
 
     if storage_type == StorageType.S3:
 
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
             if range is None:
-                data = s3_client.get_object(
-                    Bucket='tray_name',
-                    Key='base_name',
+                data = s3_client["client"].get_object(
+                    Bucket=bucket_name,
+                    Key=base_name,
                 )['Body'].read()
             else:
-                data = s3_client.get_object(
-                    Bucket='tray_name',
-                    Key='base_name',
-                    Range=f"bytes=${range[0]}-${range[1] - range[0] - 1}"
+                data = s3_client["client"].get_object(
+                    Bucket=bucket_name,
+                    Key=base_name,
+                    Range=f"bytes={range[0]}-{range[0] + range[1] - 1}"
                 )['Body'].read()
 
         except botocore.exceptions.ClientError as e:
@@ -370,12 +379,12 @@ def put_data_str(data: str, path: str) -> None:
 
     if storage_type == StorageType.S3:
 
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            s3_client.put_object(
+            s3_client["client"].put_object(
                 Body = data.encode('utf-8'),
-                Bucket = tray_name,
+                Bucket = bucket_name,
                 Key = base_name
             )
         except Exception as e:
@@ -421,10 +430,10 @@ def get_size(path: str) -> int:
 
     if storage_type == StorageType.S3:
 
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            size = s3_client.head_object(Bucket=tray_name, Key=base_name)["ContentLength"].strip('"')
+            size = s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)["ContentLength"].strip('"')
             return int(size)
         except Exception as e:
             raise StorageError("S3", e)
@@ -477,10 +486,10 @@ def exists(path: str) -> bool:
 
     if storage_type == StorageType.S3:
 
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            s3_client.head_object(Bucket=tray_name, Key=base_name)
+            s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)
             return True
         except botocore.exceptions.ClientError as e:
             if e.response['Error']['Code'] == "404":
@@ -532,11 +541,11 @@ def remove(path: str) -> None:
 
     if storage_type == StorageType.S3:
 
-        s3_client, host, tray_name = __get_s3_client(tray_name)
+        s3_client, bucket_name = __get_s3_client(tray_name)
 
         try:
-            s3_client.delete_object(
-                Bucket=tray_name,
+            s3_client["client"].delete_object(
+                Bucket=bucket_name,
                 Key=base_name
             )
         except Exception as e:
@@ -600,13 +609,13 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
     elif from_type == StorageType.S3 and to_type == StorageType.FILE :
 
-        s3_client, host, from_tray = __get_s3_client(from_tray)
+        s3_client, from_bucket = __get_s3_client(from_tray)
 
         try:
             if to_tray != "":
                 os.makedirs(to_tray, exist_ok=True)
 
-            s3_client.download_file(from_tray, from_base_name, to_path)
+            s3_client["client"].download_file(from_bucket, from_base_name, to_path)
 
             if from_md5 is not None :
                 to_md5 = hash_file(to_path)
@@ -618,13 +627,13 @@ 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, host, to_tray = __get_s3_client(to_tray)
+        s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            s3_client.upload_file(from_path, to_tray, to_base_name)
+            s3_client["client"].upload_file(from_path, to_bucket, to_base_name)
 
             if from_md5 is not None :
-                to_md5 = s3_client.head_object(Bucket=to_tray, Key=to_base_name)["ETag"].strip('"')
+                to_md5 = s3_client["client"].head_object(Bucket=to_bucket, Key=to_base_name)["ETag"].strip('"')
                 if to_md5 != from_md5:
                     raise StorageError(f"FILE and S3", f"Invalid MD5 sum control for copy file {from_path} to S3 object {to_path} : {from_md5} != {to_md5}")
         except Exception as e:
@@ -632,25 +641,25 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
     elif from_type == StorageType.S3 and to_type == StorageType.S3 :
 
-        from_s3_client, from_host, from_tray = __get_s3_client(from_tray)
-        to_s3_client, to_host, to_tray = __get_s3_client(to_tray)
+        from_s3_client, from_bucket = __get_s3_client(from_tray)
+        to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            if to_host == from_host:
-                to_s3_client.copy(
+            if to_s3_client["host"] == from_s3_client["host"]:
+                to_s3_client["client"].copy(
                     {
-                        'Bucket': from_tray,
+                        'Bucket': from_bucket,
                         'Key': from_base_name
                     },
-                    to_tray, to_base_name
+                    to_bucket, to_base_name
                 )
             else:
                 with tempfile.NamedTemporaryFile("w+b") as f:
-                    from_s3_client.download_fileobj(from_tray, from_base_name, f)
-                    to_s3_client.upload_file(f.name, to_tray, to_base_name)
+                    from_s3_client["client"].download_fileobj(from_bucket, from_base_name, f)
+                    to_s3_client["client"].upload_file(f.name, to_bucket, to_base_name)
 
             if from_md5 is not None :
-                to_md5 = to_s3_client.head_object(Bucket=to_tray, Key=to_base_name)["ETag"].strip('"')
+                to_md5 = to_s3_client["client"].head_object(Bucket=to_bucket, Key=to_base_name)["ETag"].strip('"')
                 if to_md5 != from_md5:
                     raise StorageError(f"S3", f"Invalid MD5 sum control for copy S3 object {from_path} to {to_path} : {from_md5} != {to_md5}")
 
@@ -765,7 +774,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
         from_ioctx = __get_ceph_ioctx(from_tray)
 
-        to_s3_client, to_host, to_tray = __get_s3_client(to_tray)
+        s3_client, to_bucket = __get_s3_client(to_tray)
 
         if from_md5 is not None:
             checker = hashlib.md5()
@@ -775,7 +784,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             size = 0
 
             with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
-                name_fich = f.name
+                name_tmp = f.name
                 while True:
                     chunk = from_ioctx.read(from_base_name, 65536, offset)
                     size = len(chunk)
@@ -788,18 +797,13 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                     if size < 65536:
                         break
 
-            to_s3_client.upload_file(name_fich, to_tray, to_base_name)
+            s3_client["client"].upload_file(name_tmp, to_bucket, to_base_name)
 
-            os.remove(name_fich)
+            os.remove(name_tmp)
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
                 raise StorageError(f"CEPH and S3", f"Invalid MD5 sum control for copy CEPH object {from_path} to S3 object {to_path} : {from_md5} != {checker.hexdigest()}")
 
-            if from_md5 is not None :
-                to_md5 = to_s3_client.head_object(Bucket=to_tray, Key=to_base_name)["ETag"].strip('"')
-                if to_md5 != from_md5 and "-" not in to_md5:
-                    raise StorageError(f"CEPH and S3", f"Invalid MD5 sum control for copy CEPH object {from_path} to S3 object {to_path} : {from_md5} != {to_md5}")
-
         except Exception as e:
             raise StorageError(f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}")
 
@@ -833,7 +837,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
     elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.S3 :
 
-        to_s3_client, to_host, to_tray = __get_s3_client(to_tray)
+        to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
             reponse = requests.get(from_path, stream = True)
@@ -843,7 +847,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                     if chunk:
                         f.write(chunk)
 
-            to_s3_client.upload_file(name_fich, to_tray, to_base_name)
+            to_s3_client["client"].upload_file(name_fich, to_tray, to_base_name)
 
             os.remove(name_fich)
 
@@ -880,16 +884,16 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
     # Réalisation du lien, selon les types de stockage
     if target_type == StorageType.S3:
 
-        target_s3_client, target_host, target_tray = __get_s3_client(target_tray)
-        link_s3_client, link_host, link_tray = __get_s3_client(link_tray)
+        target_s3_client, target_bucket = __get_s3_client(target_tray)
+        link_s3_client, link_bucket = __get_s3_client(link_tray)
 
-        if link_host != target_host:
+        if target_s3_client["host"] != link_s3_client["host"]:
             raise StorageError(f"S3", f"Cannot make link {link_path} -> {target_path} : link works only on the same S3 cluster")
 
         try:
-            target_s3_client.put_object(
-                Body = f"{__OBJECT_SYMLINK_SIGNATURE}{target_tray}/{target_base_name}".encode('utf-8'),
-                Bucket = link_tray,
+            target_s3_client["client"].put_object(
+                Body = f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode('utf-8'),
+                Bucket = link_bucket,
                 Key = link_base_name
             )
         except Exception as e:
@@ -916,3 +920,40 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
 
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to make link")
+
+def get_osgeo_path(path: str) -> str:
+    """Return GDAL/OGR Open compliant path and configure storage access
+
+    For a S3 input path, endpoint, access and secret keys are set and path is built with "/vsis3" root.
+
+    For a FILE input path, only storage prefix is removed
+
+    Args:
+        path (str): Source path
+
+    Raises:
+        NotImplementedError: Storage type not handled
+
+    Returns:
+        str: GDAL/OGR Open compliant path
+    """
+
+    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
+
+
+    if storage_type == StorageType.S3:
+
+        s3_client, bucket_name = __get_s3_client(tray_name)
+
+        gdal.SetConfigOption('AWS_SECRET_ACCESS_KEY', s3_client["secret_key"])
+        gdal.SetConfigOption('AWS_ACCESS_KEY_ID', s3_client["key"])
+        gdal.SetConfigOption('AWS_S3_ENDPOINT', s3_client["host"])
+        gdal.SetConfigOption('AWS_VIRTUAL_HOSTING', 'FALSE')
+
+        return f"/vsis3/{bucket_name}/{base_name}"
+
+    elif storage_type == StorageType.FILE:
+        return unprefixed_path
+
+    else:
+        raise NotImplementedError(f"Cannot get a GDAL/OGR compliant path from {path}")
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 9f73ae4..862b5a0 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -138,7 +138,7 @@ def test_http_read_error(mock_http):
         mock_http.return_value = requests_instance
         data = get_data_str("http:///path/to/file.ext")
 
-    mock_http.assert_called_with("http:///path/to/file.ext")
+    mock_http.assert_called_with("http:///path/to/file.ext", stream=True)
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("requests.get")
@@ -149,7 +149,7 @@ def test_http_read_ok(mock_http):
         mock_http.return_value = requests_instance
 
         data = get_data_str("http:///path/to/file.ext")
-        mock_http.assert_called_with("http:///path/to/file.ext")
+        mock_http.assert_called_with("http:///path/to/file.ext", stream=True)
         assert data == 'data'
     except Exception as exc:
         assert False, f"HTTP read raises an exception: {exc}"
@@ -725,3 +725,31 @@ def test_remove_s3_ok(mocked_s3_client):
         remove("s3://bucket/object.ext")
     except Exception as exc:
         assert False, f"S3 deletion raises an exception: {exc}"
+
+
+############ get_osgeo_path
+
+@mock.patch.dict(os.environ, {}, clear=True)
+def test_get_osgeo_path_file_ok():
+    try:
+        path = get_osgeo_path("file:///path/to/file.ext")
+        assert path == "/path/to/file.ext"
+    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)
+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"
+    except Exception as exc:
+        assert False, f"S3 osgeo path raises an exception: {exc}"
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+def test_get_osgeo_path_nok():
+    with pytest.raises(NotImplementedError):
+        get_osgeo_path("ceph://pool/data.ext")
diff --git a/tests/test_Utils.py b/tests/test_Utils.py
index f5dfe6a..075e7d9 100644
--- a/tests/test_Utils.py
+++ b/tests/test_Utils.py
@@ -3,6 +3,7 @@
 
 import pytest
 import os
+import math
 
 from unittest.mock import *
 from unittest import mock
@@ -52,7 +53,10 @@ def test_reproject_point_ok():
         sr_3857 = srs_to_spatialreference("EPSG:3857")
         sr_ignf = srs_to_spatialreference("IGNF:WGS84G")
         x,y = reproject_point((43, 3), sr_4326, sr_3857)
-        assert (x,y) == (333958.4723798207, 5311971.846945471)
+
+        assert math.isclose(x, 333958.4723798207, rel_tol=1e-5)
+        assert math.isclose(y, 5311971.846945471, rel_tol=1e-5)
+
         x,y = reproject_point((43, 3), sr_4326, sr_ignf)
         assert (x,y) == (3, 43)
 

From e8adcfda816f0d353723369f898d6c8acfa6daca Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Mon, 3 Apr 2023 14:48:33 +0200
Subject: [PATCH 15/89] =?UTF-8?q?Lecture=20d'informations=20sur=20une=20do?=
 =?UTF-8?q?nn=C3=A9e=20raster=20unique=20depuis=20un=20fichier=20ou=20une?=
 =?UTF-8?q?=20liste=20de=20param=C3=A8tres.=20Les=20informations=20lues=20?=
 =?UTF-8?q?incluents=20:=20le=20chemin=20vers=20la=20donn=C3=A9e=20raster,?=
 =?UTF-8?q?=20le=20chemin=20=C3=A9ventuel=20vers=20sont=20masque=20associ?=
 =?UTF-8?q?=C3=A9,=20le=20nombre=20de=20de=20canaux=20de=20couleur,=20leur?=
 =?UTF-8?q?=20format=20de=20variable,=20les=20dimensions=20de=20l'image,?=
 =?UTF-8?q?=20et=20la=20boudingbox=20correspondante=20dans=20la=20projecti?=
 =?UTF-8?q?on=20de=20l'image.=20Les=20m=C3=A9thodes=20de=20lecture=20inclu?=
 =?UTF-8?q?ent=20:=20directement=20depuis=20le=20donn=C3=A9e=20raster,=20o?=
 =?UTF-8?q?u=20depuis=20une=20liste=20de=20param=C3=A8tres=20issus=20par?=
 =?UTF-8?q?=20exemple=20d'une=20ex=C3=A9cution=20pr=C3=A9c=C3=A9dente.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Réserve : la gestion des boundingbox ne tient actuellement par compte de l'ordre des coordonnées dans le système de référence de la donnée raster.
---
 CHANGELOG.md         | 21 +++++++++-------
 README.md            |  7 ++++--
 src/rok4/Raster.py   | 57 +++++++++++++++++++++++++++++++++++++-------
 tests/test_Raster.py | 36 +++++++++++++++++++---------
 4 files changed, 90 insertions(+), 31 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a24c5b..a9d52f5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,20 +1,23 @@
 ## Summary
 
-Lecture facilitée de la liste d'une pyramide.
+Lecture d'informations sur une donnée raster unique depuis un fichier ou une liste de paramètres.
 
 ## 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]
+* Raster
+    * Chargement des informations sur un fichier raster (chemin du fichier, chemin du fichier de masque si applicable, nombre de canaux, boundingbox de l'emprise géographique)
+        * depuis le fichier raster
+        * depuis une liste de paramètres provenant d'une utilisation précédente
+    * Tests unitaires
+    * Documentation interne des fonctions et classes
+
+### [Changed]
+
+* README.md
+    * Modification du bloc code de compilation pour utiliser explicitement python3, et installer certaines dépendances.
 
-* Storage
-    * Lecture de la taille d'un objet S3 : pas besoin d'enlever des quotes dans le header `Content-Length`
 <!--
 ### [Added]
 
diff --git a/README.md b/README.md
index 9cf6497..159c85e 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ Plus d'exemple dans la documentation développeur.
 ## Compiler la librairie
 
 ```sh
-apt install python3-venv python3-rados python3-gdal # user input required for gdal dependencies, unless DEBIAN_FRONTEND=noninteractive
+apt install python3-venv python3-rados python3-gdal
 python3 -m venv .venv
 source .venv/bin/activate
 python3 -m pip install --upgrade build bump2version
@@ -47,7 +47,7 @@ bump2version --allow-dirty --current-version 0.0.0 --new-version x.y.z patch pyp
 python3 -m pip install -e .[test]
 # To use system installed modules rados and osgeo
 echo "/usr/lib/python3/dist-packages/" >.venv/lib/python3.10/site-packages/system.pth
-python -c 'import sys; print (sys.path)'
+python3 -c 'import sys; print (sys.path)'
 # Run tests
 coverage run -m pytest
 # Get tests report and generate site
@@ -62,6 +62,9 @@ pdoc3 --html --output-dir dist/ rok4
 python3 -m build
 ```
 
+Remarque :
+Lors de l'installation du paquet apt `python3-gdal`, une dépendance, peut demander des interactions de configuration. Pour installer dans un environnement non-interactif, définir la variable shell `DEBIAN_FRONTEND=noninteractive` permet d'adopter une configuration par défaut.
+
 ## Publier la librairie sur Pypi
 
 Configurer le fichier `$HOME/.pypirc` avec les accès à votre compte PyPI.
diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 449db2c..3583b7d 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -7,17 +7,19 @@
 """
 
 import re
-import tempfile
 from enum import Enum
 
 from osgeo import ogr, gdal
 
-from rok4.Storage import exists, get_infos_from_path, copy, StorageType, get_osgeo_path
+from rok4.Storage import exists, get_osgeo_path
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
 class ColorFormat(Enum):
+    """A color format enumeration.
+    Except from "BIT", the member's name matches a common variable format name. The member's value is the allocated bit size associated to this format.
+    """
     BIT = 1
     UINT8 = 8
     FLOAT32 = 32
@@ -35,6 +37,14 @@ class Raster():
         dimensions (Tuple[int, int]): image width and height expressed in pixels
     """
 
+    def __init__(self) -> None:
+        self.bands = None
+        self.bbox = (None, None, None, None)
+        self.dimensions = (None, None)
+        self.format = None
+        self.mask = None
+        self.path = None
+
     @classmethod
     def from_file(cls, path: str) -> 'Raster':
         """Creates a Raster object from an image
@@ -42,10 +52,21 @@ def from_file(cls, path: str) -> 'Raster':
         Args:
             path (str): path to the image file/object
 
+        Examples:
+
+            Loading informations from a file stored raster TIFF image
+
+                from rok4.Raster import Raster
+
+                try:
+                    raster = Raster.from_file("file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.tif")
+
+                except Exception as e:
+                    print(f"Cannot load information from image : {e}")
+
         Raises:
             RuntimeError: raised by OGR/GDAL if anything goes wrong
-            MissingEnvironmentError: Missing object storage informations
-            StorageError: Storage read issue
+            NotImplementedError: Storage type not handled
 
         Returns:
             Raster: a Raster instance
@@ -93,6 +114,18 @@ def from_parameters(cls, mask=None, **kwargs):
             **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
             **dimensions (Tuple[int, int]): image width and height expressed in pixels
 
+        Examples:
+
+            Loading informations from parameters, related to a TIFF main image coupled to a TIFF mask image
+
+                from rok4.Raster import Raster
+
+                try:
+                    raster = Raster.from_parameters(path="file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.tif", mask="file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.msk", bands=3, format=ColorFormat.UINT8, dimensions=(2000, 2000), bbox=(40000.000, 5950000.000, 240000.000, 6150000.000))
+
+                except Exception as e:
+                    print(f"Cannot load information from parameters : {e}")
+
         Raises:
             KeyError: a mandatory argument is missing
 
@@ -172,16 +205,22 @@ def _compute_format(dataset: gdal.Dataset, path=None) -> ColorFormat:
         raise Exception(f"Image {path} contains no color band.")
     
     band_1_datatype = dataset.GetRasterBand(1).DataType
-    band_1_color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
+    data_type_name = gdal.GetDataTypeName(band_1_datatype)
+    data_type_size = gdal.GetDataTypeSize(band_1_datatype)
+    color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
+    color_name = None
+    if color_interpretation is not None:
+        color_name = gdal.GetColorInterpretationName(color_interpretation)
     compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
 
-    if gdal.GetDataTypeName(band_1_datatype) == "Byte" and gdal.GetDataTypeSize(band_1_datatype) == 8 and compression_regex_match and band_1_color_interpretation is not None and gdal.GetColorInterpretationName(band_1_color_interpretation) == "Palette":
+
+    if data_type_name == "Byte" and data_type_size == 8 and color_name == "Palette" and compression_regex_match:
         format = ColorFormat.BIT
-    elif gdal.GetDataTypeName(band_1_datatype) == "Byte" and gdal.GetDataTypeSize(band_1_datatype) == 8:
+    elif data_type_name == "Byte" and data_type_size == 8:
         format = ColorFormat.UINT8
-    elif gdal.GetDataTypeName(band_1_datatype) == "Float32" and gdal.GetDataTypeSize(band_1_datatype) == 32:
+    elif data_type_name == "Float32" and data_type_size == 32:
         format = ColorFormat.FLOAT32
     else:
-        raise Exception(f"Unsupported color format for image {path} : '{gdal.GetDataTypeName(band_1_datatype)}' ({gdal.GetDataTypeSize(band_1_datatype)} bits)")
+        raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
 
     return format
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 70afbc1..4c75833 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,14 +1,13 @@
 """Describes unit tests for the rok4.Raster module."""
 
 from rok4.Raster import ColorFormat, Raster, _compute_bbox, _compute_format
-from rok4.Storage import StorageType
 
 from osgeo import gdal
-import random
+import random, math
 
 import pytest
+from unittest import mock, TestCase
 from unittest.mock import *
-from unittest import mock, TestCase, skip
 
 class TestComputeBbox(TestCase):
     """Test class for the rok4.Raster._compute_bbox function."""
@@ -50,7 +49,10 @@ def test_nominal(self):
             max(y_range)
         )
         result = _compute_bbox(mocked_datasource)
-        assert expected == result
+        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
+        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
+        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
+        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
 
 
 class TestComputeFormat(TestCase):
@@ -112,7 +114,7 @@ def test_uint8(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetC
         assert result == ColorFormat.UINT8
         mocked_GetDataTypeName.assert_called()
         mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_GetColorInterpretationName.assert_called()
         mocked_Info.assert_called()
 
     @mock.patch('rok4.Raster.gdal.Info')
@@ -137,7 +139,7 @@ def test_float32(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_Ge
         assert result == ColorFormat.FLOAT32
         mocked_GetDataTypeName.assert_called()
         mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_GetColorInterpretationName.assert_called()
         mocked_Info.assert_called()
 
     @mock.patch('rok4.Raster.gdal.Info')
@@ -162,7 +164,7 @@ def test_unsupported(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocke
         
         mocked_GetDataTypeName.assert_called()
         mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_GetColorInterpretationName.assert_called()
         mocked_Info.assert_called()
 
     @mock.patch('rok4.Raster.gdal.Info')
@@ -231,7 +233,10 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
         assert raster_object.mask is None
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
+        assert math.isclose(raster_object.bbox[0], self.bbox[0], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[1], self.bbox[1], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[2], self.bbox[2], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[3], self.bbox[3], rel_tol=1e-5)
         assert raster_object.bands == 3
         mocked_compute_format.assert_called_once()
         assert raster_object.format == ColorFormat.UINT8
@@ -262,7 +267,10 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_op
         assert raster_object.mask == self.source_mask_path
 
         mocked_compute_bbox.assert_called_once()
-        assert raster_object.bbox == self.bbox
+        assert math.isclose(raster_object.bbox[0], self.bbox[0], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[1], self.bbox[1], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[2], self.bbox[2], rel_tol=1e-5)
+        assert math.isclose(raster_object.bbox[3], self.bbox[3], rel_tol=1e-5)
         assert raster_object.bands == 3
         mocked_compute_format.assert_called_once()
         assert raster_object.format == ColorFormat.UINT8
@@ -316,7 +324,10 @@ def test_image(self):
         result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions)
 
         assert result.path == i_path
-        assert result.bbox == i_bbox
+        assert math.isclose(result.bbox[0], i_bbox[0], rel_tol=1e-5)
+        assert math.isclose(result.bbox[1], i_bbox[1], rel_tol=1e-5)
+        assert math.isclose(result.bbox[2], i_bbox[2], rel_tol=1e-5)
+        assert math.isclose(result.bbox[3], i_bbox[3], rel_tol=1e-5)
         assert result.bands == i_bands
         assert result.format == i_format
         assert result.dimensions == i_dimensions
@@ -333,7 +344,10 @@ def test_image_and_mask(self):
         result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions, mask=i_mask)
 
         assert result.path == i_path
-        assert result.bbox == i_bbox
+        assert math.isclose(result.bbox[0], i_bbox[0], rel_tol=1e-5)
+        assert math.isclose(result.bbox[1], i_bbox[1], rel_tol=1e-5)
+        assert math.isclose(result.bbox[2], i_bbox[2], rel_tol=1e-5)
+        assert math.isclose(result.bbox[3], i_bbox[3], rel_tol=1e-5)
         assert result.bands == i_bands
         assert result.format == i_format
         assert result.dimensions == i_dimensions

From a5ad9718bf3629d4d13ff8e69cef920135b46fbf Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Wed, 5 Apr 2023 18:40:56 +0200
Subject: [PATCH 16/89] =?UTF-8?q?Prise=20en=20compte=20de=20l'ordre=20des?=
 =?UTF-8?q?=20axes=20selon=20le=20CRS=20pour=20les=20BBOX=20raster.=20D?=
 =?UTF-8?q?=C3=A9placement=20des=20fonctions=20publiques=20statiques=20de?=
 =?UTF-8?q?=20Raster=20vers=20Utils.=20Diverses=20corrections=20de=20style?=
 =?UTF-8?q?.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md         |   3 +
 src/rok4/Pyramid.py  |  12 +-
 src/rok4/Raster.py   | 100 +-------------
 src/rok4/Utils.py    | 113 +++++++++++++++-
 tests/test_Raster.py | 189 +-------------------------
 tests/test_Utils.py  | 310 +++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 443 insertions(+), 284 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a9d52f5..e93aeb8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,9 @@ Lecture d'informations sur une donnée raster unique depuis un fichier ou une li
 
 * README.md
     * Modification du bloc code de compilation pour utiliser explicitement python3, et installer certaines dépendances.
+* Utils
+    * Fonction de calcul de la boundix box d'une donnée
+    * Fonction de détermination du format de variable des couleurs dans une donéne raster
 
 <!--
 ### [Added]
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index bc9e669..6263aaf 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -31,7 +31,7 @@ class PyramidType(Enum):
 class SlabType(Enum):
     """ Slab's type """
     DATA = "DATA" # Slab of data, raster or vector
-    MASK = "MASK" # Slab of mask, only for raster pyramide, image with one band : 0 is nodata, other values are data
+    MASK = "MASK" # Slab of mask, only for raster pyramid, image with one band : 0 is nodata, other values are data
 
 
 ROK4_IMAGE_HEADER_SIZE = 2048
@@ -794,11 +794,11 @@ def get_level(self, level_id: str) -> 'Level':
 
 
     def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
-        """Get sorted levels from bottom to top provided
+        """Get sorted levels in the provided range from bottom to top
 
         Args:
-            bottom_id (str): optionnal specific bottom level id. Defaults to None.
-            top_id (str): optionnal specific top level id. Defaults to None.
+            bottom_id (str, optionnal): specific bottom level id. Defaults to None.
+            top_id (str, optionnal): specific top level id. Defaults to None.
 
         Raises:
             Exception: Provided levels are not consistent (bottom > top or not in the pyramid)
@@ -969,7 +969,7 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         """Get a pyramid's tile as binary string
 
         To get a tile, 3 steps :
-            * calculate slab path from tile indice
+            * calculate slab path from tile index
             * read slab index to get offsets and sizes of slab's tiles
             * read the tile into the slab
 
@@ -1243,7 +1243,7 @@ def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
     def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> Tuple[str, int, int, int, int]:
         """Get pyramid's tile and pixel indices from point's coordinates
 
-        Used coordinates system have to be the pyramide one. If EPSG:4326, x is latitude and y longitude.
+        Used coordinates system have to be the pyramid one. If EPSG:4326, x is latitude and y longitude.
 
         Args:
             x (float): point's x
diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 3583b7d..1d20fd6 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -12,20 +12,13 @@
 from osgeo import ogr, gdal
 
 from rok4.Storage import exists, get_osgeo_path
+from rok4.Utils import ColorFormat, compute_bbox,compute_format
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
-class ColorFormat(Enum):
-    """A color format enumeration.
-    Except from "BIT", the member's name matches a common variable format name. The member's value is the allocated bit size associated to this format.
-    """
-    BIT = 1
-    UINT8 = 8
-    FLOAT32 = 32
-
 
-class Raster():
+class Raster:
     """A structure describing raster data
 
     Attributes :
@@ -95,23 +88,23 @@ def from_file(cls, path: str) -> 'Raster':
         else:
             self.mask = None
 
-        self.bbox = _compute_bbox(image_datasource)
+        self.bbox = compute_bbox(image_datasource)
         self.bands = image_datasource.RasterCount
-        self.format = _compute_format(image_datasource, path)
+        self.format = compute_format(image_datasource, path)
         self.dimensions = (image_datasource.RasterXSize, image_datasource.RasterYSize)
 
         return self
 
     @classmethod
-    def from_parameters(cls, mask=None, **kwargs):
+    def from_parameters(cls, mask: str = None, **kwargs) -> 'Raster':
         """Creates a Raster object from key/value parameters
 
         Args:
+            **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
             **path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
             **bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
             **bands (int): number of color bands (or channels)
             **format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
-            **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
             **dimensions (Tuple[int, int]): image width and height expressed in pixels
 
         Examples:
@@ -143,84 +136,3 @@ def from_parameters(cls, mask=None, **kwargs):
         self.dimensions = kwargs["dimensions"]
 
         return self
-
-
-def _compute_bbox(source_dataset: gdal.Dataset) -> tuple:
-    """Image boundingbox computing method
-
-    Args:
-        source_dataset (gdal.Dataset): Dataset object created from the raster image
-
-    Raises:
-        AttributeError: source_dataset is not a gdal.Dataset instance.
-        Exception: The dataset does not contain transform data.
-    """
-
-    transform_vector = source_dataset.GetGeoTransform()
-
-    if transform_vector is None:
-        raise Exception(f"No transform vector found in the dataset created from the following file : {source_dataset.GetFileList()[0]}")
-
-    width = source_dataset.RasterXSize
-    height = source_dataset.RasterYSize
-
-    x_range = (
-        transform_vector[0],
-        transform_vector[0] + width * transform_vector[1] + height * transform_vector[2]
-    )
-
-    y_range = (
-        transform_vector[3],
-        transform_vector[3] + width * transform_vector[4] + height * transform_vector[5]
-    )
-
-    bbox = (
-            min(x_range),
-            min(y_range),
-            max(x_range),
-            max(y_range)
-    )
-
-    return bbox
-
-
-def _compute_format(dataset: gdal.Dataset, path=None) -> ColorFormat:
-    """Image color format computing method
-
-    Args:
-        dataset (gdal.Dataset): Dataset object created from the raster image
-        path (str): path to the original file/object (optionnal)
-
-    Raises:
-        AttributeError: source_dataset is not a gdal.Dataset instance.
-        Exception: Image has no color band or its color format is unsupported.
-    """
-
-    format = None
-
-    if path is None:
-        path = dataset.GetFileList()[0]
-
-    if dataset.RasterCount < 1:
-        raise Exception(f"Image {path} contains no color band.")
-    
-    band_1_datatype = dataset.GetRasterBand(1).DataType
-    data_type_name = gdal.GetDataTypeName(band_1_datatype)
-    data_type_size = gdal.GetDataTypeSize(band_1_datatype)
-    color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
-    color_name = None
-    if color_interpretation is not None:
-        color_name = gdal.GetColorInterpretationName(color_interpretation)
-    compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
-
-
-    if data_type_name == "Byte" and data_type_size == 8 and color_name == "Palette" and compression_regex_match:
-        format = ColorFormat.BIT
-    elif data_type_name == "Byte" and data_type_size == 8:
-        format = ColorFormat.UINT8
-    elif data_type_name == "Float32" and data_type_size == 32:
-        format = ColorFormat.FLOAT32
-    else:
-        raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
-
-    return format
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 7f8260b..548f5f7 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -2,12 +2,25 @@
 """
 
 import os
+import re
 
 from typing import Dict, List, Tuple, Union
-from osgeo import ogr, osr
+from osgeo import ogr, osr, gdal
+from enum import Enum
+
 ogr.UseExceptions()
 osr.UseExceptions()
 
+
+class ColorFormat(Enum):
+    """A color format enumeration.
+    Except from "BIT", the member's name matches a common variable format name. The member's value is the allocated bit size associated to this format.
+    """
+    BIT = 1
+    UINT8 = 8
+    FLOAT32 = 32
+
+
 __SR_BOOK = dict()
 def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
     """Convert coordinates system as string to OSR spatial reference
@@ -154,4 +167,100 @@ def reproject_point(point: Tuple[float, float], sr_src: 'osgeo.osr.SpatialRefere
     ct = osr.CreateCoordinateTransformation(sr_src, sr_dst)
     x_dst, y_dst, z_dst = ct.TransformPoint(point[0], point[1])
 
-    return (x_dst, y_dst)
\ No newline at end of file
+    return (x_dst, y_dst)
+
+
+def compute_bbox(source_dataset: gdal.Dataset) -> tuple:
+    """Image boundingbox computing method
+
+    Args:
+        source_dataset (gdal.Dataset): Dataset object created from the raster image
+    
+    Limitations:
+        Image's axis must be parallel to SRS' axis
+
+    Raises:
+        AttributeError: source_dataset is not a gdal.Dataset instance.
+        Exception: The dataset does not contain transform data.
+    """
+
+    bbox = None
+    transform_vector = source_dataset.GetGeoTransform()
+
+    if transform_vector is None:
+        raise Exception(f"No transform vector found in the dataset created from the following file : {source_dataset.GetFileList()[0]}")
+
+    width = source_dataset.RasterXSize
+    height = source_dataset.RasterYSize
+
+    x_range = (
+        transform_vector[0],
+        transform_vector[0] + width * transform_vector[1] + height * transform_vector[2]
+    )
+
+    y_range = (
+        transform_vector[3],
+        transform_vector[3] + width * transform_vector[4] + height * transform_vector[5]
+    )
+
+    spatial_ref = source_dataset.GetSpatialRef()
+    if spatial_ref is not None and spatial_ref.GetDataAxisToSRSAxisMapping() == [2, 1]:
+        # Coordonnées terrain de type (latitude, longitude) => on permute les coordonnées terrain par rapport à l'image
+        bbox = (
+            min(y_range),
+            min(x_range),
+            max(y_range),
+            max(x_range)
+        )
+    elif spatial_ref is None or spatial_ref.GetDataAxisToSRSAxisMapping() == [1, 2]:
+        # Coordonnées terrain de type (longitude, latitude) ou pas de SRS => les coordonnées terrain sont dans le même ordre que celle de l'image
+        bbox = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+        )
+
+    return bbox
+
+
+def compute_format(dataset: gdal.Dataset, path: str = None) -> 'ColorFormat':
+    """Image color format computing method
+
+    Args:
+        dataset (gdal.Dataset): Dataset object created from the raster image
+        path (str, optionnal): path to the original file/object
+
+    Raises:
+        AttributeError: source_dataset is not a gdal.Dataset instance.
+        Exception: Image has no color band or its color format is unsupported.
+    """
+
+    format = None
+
+    if path is None:
+        path = dataset.GetFileList()[0]
+
+    if dataset.RasterCount < 1:
+        raise Exception(f"Image {path} contains no color band.")
+    
+    band_1_datatype = dataset.GetRasterBand(1).DataType
+    data_type_name = gdal.GetDataTypeName(band_1_datatype)
+    data_type_size = gdal.GetDataTypeSize(band_1_datatype)
+    color_interpretation = dataset.GetRasterBand(1).GetRasterColorInterpretation()
+    color_name = None
+    if color_interpretation is not None:
+        color_name = gdal.GetColorInterpretationName(color_interpretation)
+    compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
+
+
+    if data_type_name == "Byte" and data_type_size == 8 and color_name == "Palette" and compression_regex_match:
+        format = ColorFormat.BIT
+    elif data_type_name == "Byte" and data_type_size == 8:
+        format = ColorFormat.UINT8
+    elif data_type_name == "Float32" and data_type_size == 32:
+        format = ColorFormat.FLOAT32
+    else:
+        raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
+
+    return format
\ No newline at end of file
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 4c75833..d7b2b24 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,189 +1,14 @@
 """Describes unit tests for the rok4.Raster module."""
 
-from rok4.Raster import ColorFormat, Raster, _compute_bbox, _compute_format
+from rok4.Raster import Raster
+from rok4.Utils import ColorFormat
 
-from osgeo import gdal
-import random, math
+import math
 
 import pytest
 from unittest import mock, TestCase
 from unittest.mock import *
 
-class TestComputeBbox(TestCase):
-    """Test class for the rok4.Raster._compute_bbox function."""
-
-    def test_nominal(self):
-        mocked_datasource = MagicMock(gdal.Dataset)
-        random.seed()
-
-        image_size = (
-            random.randint(1, 1000),
-            random.randint(1, 1000)
-        )
-        mocked_datasource.RasterXSize = image_size[0]
-        mocked_datasource.RasterYSize = image_size[1]
-
-        transform_tuple = (
-            random.uniform(-10000000.0, 10000000.0),
-            random.uniform(-10000, 10000),
-            random.uniform(-10000, 10000),
-            random.uniform(-10000000.0, 10000000.0),
-            random.uniform(-10000, 10000),
-            random.uniform(-10000, 10000)
-        )
-        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
-
-        x_range = (
-            transform_tuple[0],
-            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
-        )
-        y_range = (
-            transform_tuple[3],
-            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
-        )
-
-        expected = (
-            min(x_range),
-            min(y_range),
-            max(x_range),
-            max(y_range)
-        )
-        result = _compute_bbox(mocked_datasource)
-        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
-        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
-        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
-        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
-
-
-class TestComputeFormat(TestCase):
-    """Test class for the rok4.Raster._compute_format function."""
-
-    def setUp(self) -> None:
-        self.bit_gdalinfo = """Driver: GTiff/GeoTIFF
-Size is 10000, 10000
-Image Structure Metadata:
-  COMPRESSION=PACKBITS
-  INTERLEAVE=BAND
-  MINISWHITE=YES
-"""
-        self.common_gdalinfo = """Driver: GTiff/GeoTIFF
-Size is 10000, 10000
-Metadata:
-  AREA_OR_POINT=Area
-Image Structure Metadata:
-  INTERLEAVE=BAND
-"""
-        return super().setUp()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName', return_value="Palette")
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=8)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Byte")
-    def test_bit(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-
-        mocked_datasource.RasterCount = 1
-        mocked_Info.return_value = self.bit_gdalinfo
-
-        result = _compute_format(mocked_datasource)
-        assert result == ColorFormat.BIT
-        mocked_GetDataTypeName.assert_called()
-        mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_called()
-        mocked_Info.assert_called()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=8)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Byte")
-    def test_uint8(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-        
-        band_number = random.randint(1, 4)
-        mocked_datasource.RasterCount = band_number
-        band_name = None
-        if band_number == 1 or band_number == 2:
-            band_name = "Gray"
-        elif band_number == 3 or band_number == 4:
-            band_name = "Red"
-        mocked_GetColorInterpretationName.return_value = band_name
-        mocked_Info.return_value = self.common_gdalinfo
-
-        result = _compute_format(mocked_datasource)
-
-        assert result == ColorFormat.UINT8
-        mocked_GetDataTypeName.assert_called()
-        mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_called()
-        mocked_Info.assert_called()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=32)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="Float32")
-    def test_float32(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-        
-        band_number = random.randint(1, 4)
-        mocked_datasource.RasterCount = band_number
-        band_name = None
-        if band_number == 1 or band_number == 2:
-            band_name = "Gray"
-        elif band_number == 3 or band_number == 4:
-            band_name = "Red"
-        mocked_GetColorInterpretationName.return_value = band_name
-        mocked_Info.return_value = self.common_gdalinfo
-
-        result = _compute_format(mocked_datasource)
-
-        assert result == ColorFormat.FLOAT32
-        mocked_GetDataTypeName.assert_called()
-        mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_called()
-        mocked_Info.assert_called()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=16)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="UInt16")
-    def test_unsupported(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-
-        band_number = random.randint(1, 4)
-        mocked_datasource.RasterCount = band_number
-        band_name = None
-        if band_number == 1 or band_number == 2:
-            band_name = "Gray"
-        elif band_number == 3 or band_number == 4:
-            band_name = "Red"
-        mocked_GetColorInterpretationName.return_value = band_name
-        mocked_Info.return_value = self.common_gdalinfo
-
-        with pytest.raises(Exception):
-            _compute_format(mocked_datasource)
-        
-        mocked_GetDataTypeName.assert_called()
-        mocked_GetDataTypeSize.assert_called()
-        mocked_GetColorInterpretationName.assert_called()
-        mocked_Info.assert_called()
-
-    @mock.patch('rok4.Raster.gdal.Info')
-    @mock.patch('rok4.Raster.gdal.GetColorInterpretationName')
-    @mock.patch('rok4.Raster.gdal.GetDataTypeSize', return_value=16)
-    @mock.patch('rok4.Raster.gdal.GetDataTypeName', return_value="UInt16")
-    def test_no_band(self, mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
-        mocked_datasource = MagicMock(gdal.Dataset)
-
-        mocked_datasource.RasterCount = 0
-
-        with pytest.raises(Exception):
-            _compute_format(mocked_datasource)
-
-        mocked_GetDataTypeName.assert_not_called()
-        mocked_GetDataTypeSize.assert_not_called()
-        mocked_GetColorInterpretationName.assert_not_called()
-        mocked_Info.assert_not_called()
-
 
 class TestFromFile(TestCase):
     """Test class for the rok4.Raster.Raster.from_file(path) class constructor."""
@@ -213,9 +38,9 @@ def test_image_not_found(self, mocked_exists):
         mocked_exists.assert_called_once_with(self.source_image_path)
 
     @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
+    @mock.patch('rok4.Raster.compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
+    @mock.patch('rok4.Raster.compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, False])
     def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_compute_format, mocked_get_osgeo_path):
         """Test case : Constructor called nominally on an image without mask."""
@@ -243,10 +68,10 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
         assert raster_object.dimensions == self.image_size
 
     @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster._compute_format', return_value=ColorFormat.UINT8)
+    @mock.patch('rok4.Raster.compute_format', return_value=ColorFormat.UINT8)
     @mock.patch('rok4.Raster.gdal.IdentifyDriver')
     @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster._compute_bbox')
+    @mock.patch('rok4.Raster.compute_bbox')
     @mock.patch('rok4.Raster.exists', side_effect=[True, True])
     def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_identifydriver, mocked_compute_format, mocked_get_osgeo_path):
         """Test case : Constructor called nominally on an image with mask."""
diff --git a/tests/test_Utils.py b/tests/test_Utils.py
index 075e7d9..3ba87da 100644
--- a/tests/test_Utils.py
+++ b/tests/test_Utils.py
@@ -3,7 +3,9 @@
 
 import pytest
 import os
+from osgeo import gdal, osr
 import math
+import random
 
 from unittest.mock import *
 from unittest import mock
@@ -64,3 +66,311 @@ def test_reproject_point_ok():
         assert bbox[0] == 3
     except Exception as exc:
         assert False, f"Bbox reprojection raises an exception: {exc}"
+
+
+# Tests for the rok4.Utils.compute_bbox function.
+
+def test_compute_bbox_epsg_3857_ok():
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        random.seed()
+
+        image_size = (
+            random.randint(1, 1000),
+            random.randint(1, 1000)
+        )
+        mocked_datasource.RasterXSize = image_size[0]
+        mocked_datasource.RasterYSize = image_size[1]
+
+        transform_tuple = (
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000)
+        )
+        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+        mocked_spatial_ref = MagicMock(osr.SpatialReference)
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping = Mock(return_value = [1,2])
+        mocked_datasource.GetSpatialRef = Mock(return_value = mocked_spatial_ref)
+
+        x_range = (
+            transform_tuple[0],
+            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+        )
+        y_range = (
+            transform_tuple[3],
+            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+        )
+
+        expected = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+        )
+        result = compute_bbox(mocked_datasource)
+        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
+        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
+        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
+        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
+        mocked_datasource.GetSpatialRef.assert_called_once()
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping.assert_called()
+    except Exception as exc:
+        assert False, f"Bbox computation raises an exception: {exc}"
+
+
+def test_compute_bbox_epsg_4326_ok():
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        random.seed()
+
+        image_size = (
+            random.randint(1, 1000),
+            random.randint(1, 1000)
+        )
+        mocked_datasource.RasterXSize = image_size[0]
+        mocked_datasource.RasterYSize = image_size[1]
+
+        transform_tuple = (
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000)
+        )
+        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+        mocked_spatial_ref = MagicMock(osr.SpatialReference)
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping = Mock(return_value = [2,1])
+        mocked_datasource.GetSpatialRef = Mock(return_value = mocked_spatial_ref)
+
+        x_range = (
+            transform_tuple[0],
+            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+        )
+        y_range = (
+            transform_tuple[3],
+            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+        )
+
+        expected = (
+            min(y_range),
+            min(x_range),
+            max(y_range),
+            max(x_range)
+        )
+        result = compute_bbox(mocked_datasource)
+        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
+        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
+        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
+        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
+        mocked_datasource.GetSpatialRef.assert_called_once()
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping.assert_called()
+    except Exception as exc:
+        assert False, f"Bbox computation raises an exception: {exc}"
+
+
+def test_compute_bbox_no_srs_ok():
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        random.seed()
+
+        image_size = (
+            random.randint(1, 1000),
+            random.randint(1, 1000)
+        )
+        mocked_datasource.RasterXSize = image_size[0]
+        mocked_datasource.RasterYSize = image_size[1]
+
+        transform_tuple = (
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000000.0, 10000000.0),
+            random.uniform(-10000, 10000),
+            random.uniform(-10000, 10000)
+        )
+        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+        mocked_datasource.GetSpatialRef = Mock(return_value = None)
+
+        x_range = (
+            transform_tuple[0],
+            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+        )
+        y_range = (
+            transform_tuple[3],
+            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+        )
+
+        expected = (
+            min(x_range),
+            min(y_range),
+            max(x_range),
+            max(y_range)
+        )
+        result = compute_bbox(mocked_datasource)
+        assert math.isclose(result[0], expected[0], rel_tol=1e-5)
+        assert math.isclose(result[1], expected[1], rel_tol=1e-5)
+        assert math.isclose(result[2], expected[2], rel_tol=1e-5)
+        assert math.isclose(result[3], expected[3], rel_tol=1e-5)
+        mocked_datasource.GetSpatialRef.assert_called_once()
+    except Exception as exc:
+        assert False, f"Bbox computation raises an exception: {exc}"
+
+
+# Tests for the rok4.Utils.compute_format function.
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName', return_value="Palette")
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=8)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Byte")
+def test_compute_format_bit_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        mocked_datasource.RasterCount = 1
+        mocked_Info.return_value = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Image Structure Metadata:
+  COMPRESSION=PACKBITS
+  INTERLEAVE=BAND
+  MINISWHITE=YES
+"""
+
+        result = compute_format(mocked_datasource)
+        assert result == ColorFormat.BIT
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=8)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Byte")
+def test_compute_format_uint8_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Metadata:
+  AREA_OR_POINT=Area
+Image Structure Metadata:
+  INTERLEAVE=BAND
+"""
+
+        result = compute_format(mocked_datasource)
+
+        assert result == ColorFormat.UINT8
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=32)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Float32")
+def test_compute_format_float32_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+        
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Metadata:
+  AREA_OR_POINT=Area
+Image Structure Metadata:
+  INTERLEAVE=BAND
+"""
+
+        result = compute_format(mocked_datasource)
+
+        assert result == ColorFormat.FLOAT32
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=16)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="UInt16")
+def test_compute_format_unsupported_nok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        band_number = random.randint(1, 4)
+        mocked_datasource.RasterCount = band_number
+        band_name = None
+        if band_number == 1 or band_number == 2:
+            band_name = "Gray"
+        elif band_number == 3 or band_number == 4:
+            band_name = "Red"
+        mocked_GetColorInterpretationName.return_value = band_name
+        mocked_Info.return_value = """Driver: GTiff/GeoTIFF
+Size is 10000, 10000
+Metadata:
+  AREA_OR_POINT=Area
+Image Structure Metadata:
+  INTERLEAVE=BAND
+"""
+
+        with pytest.raises(Exception):
+            compute_format(mocked_datasource)
+        
+        mocked_GetDataTypeName.assert_called()
+        mocked_GetDataTypeSize.assert_called()
+        mocked_GetColorInterpretationName.assert_called()
+        mocked_Info.assert_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+
+
+@mock.patch('rok4.Utils.gdal.Info')
+@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
+@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=16)
+@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="UInt16")
+def test_compute_format_no_band_nok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+    try:
+        mocked_datasource = MagicMock(gdal.Dataset)
+
+        mocked_datasource.RasterCount = 0
+
+        with pytest.raises(Exception):
+            compute_format(mocked_datasource)
+
+        mocked_GetDataTypeName.assert_not_called()
+        mocked_GetDataTypeSize.assert_not_called()
+        mocked_GetColorInterpretationName.assert_not_called()
+        mocked_Info.assert_not_called()
+    except Exception as exc:
+        assert False, f"Color format computation raises an exception: {exc}"
+

From e2f82bad8ce6ccef291515c0c525852e3e4d1145 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Tue, 11 Apr 2023 15:33:42 +0200
Subject: [PATCH 17/89] =?UTF-8?q?kwargs=20au=20lieu=20param=C3=A8tres=20op?=
 =?UTF-8?q?tionnels=20+=20lecture=20CSV=20avec=20ogr=20+=20utilisation=20d?=
 =?UTF-8?q?e=20get=5Fosgeo=5Fpath?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                  |   3 -
 src/rok4/Vector.py         | 211 +++++++++++++++++++++++--------------
 tests/fixtures/vector.csv  |   4 +
 tests/fixtures/vector2.csv |   2 +
 tests/test_Vector.py       |  77 +++++---------
 5 files changed, 168 insertions(+), 129 deletions(-)
 create mode 100644 tests/fixtures/vector.csv
 create mode 100644 tests/fixtures/vector2.csv

diff --git a/README.md b/README.md
index 191feab..6069c83 100644
--- a/README.md
+++ b/README.md
@@ -29,9 +29,6 @@ from rok4.Vector import Vector
 
 try:
     tms = TileMatrixSet("file:///path/to/tms.json")
-    vector = Vector("file:///path/to/vector.shp")
-    vector_csv1 = Vector("file:///path/to/vector.csv", delimiter, column_x, column_y)
-    vector_csv1 = Vector("file:///path/to/vector.csv", delimiter, column_WKT)
 except Exception as exc:
     print(exc)
 ```
diff --git a/src/rok4/Vector.py b/src/rok4/Vector.py
index 131a0e0..1c712dd 100644
--- a/src/rok4/Vector.py
+++ b/src/rok4/Vector.py
@@ -7,7 +7,7 @@
 """
 
 from osgeo import ogr
-from rok4.Storage import get_data_str, copy
+from rok4.Storage import get_osgeo_path, copy
 from rok4.Exceptions import *
 import os
 import tempfile
@@ -24,15 +24,29 @@ class Vector :
         layers (List[Tuple[str, int, List[Tuple[str, str]]]]) : Vector layers with their name, their number of objects and their attributes
     """
 
-    def __init__(self, path: str, delimiter: str = ";", column_x : str = "x" , column_y : str = "y", column_WKT : str = None) -> None :
-        """Constructor method for Shapefile, Geopackage, CSV and GeoJSON
+    @classmethod
+    def from_file(cls, path: str, **kwargs) -> 'Vector' :
+        """Constructor method of a Vector from a file (Shapefile, Geopackage, CSV and GeoJSON)
 
         Args:
-            path: path to the file/object
-            delimiter (only for CSV) : delimiter between fields
-            column_x (only for CSV) : field of the x coordinate
-            column_y (only for CSV) : field of the y coordinate
-            column_WKT (only for CSV if geometry in WKT) : field of the WKT of the geometry
+            path (str): path to the file/object
+            **CSV (Dict[str : str]) : dictionnary of CSV parameters :
+                -srs (str) ("EPSG:2154" if not provided) : spatial reference system of the geometry
+                -column_x (str) ("x" if not provided) : field of the x coordinate
+                -column_y (str) ("y" if not provided) : field of the y coordinate
+                -column_WKT (str) (None if not provided) : field of the WKT of the geometry if WKT use to define coordinate
+
+        Examples:
+
+            from rok4.Vector import Vector
+
+            try:
+                vector = Vector.from_file("file://tests/fixtures/ARRONDISSEMENT.shp")
+                vector_csv1 = Vector.from_file("file://tests/fixtures/vector.csv" , CSV={"delimiter":";", "column_x":"x", "column_y":"y"})
+                vector_csv2 = Vector.from_file("file://tests/fixtures/vector2.csv" , CSV={"delimiter":";", "column_WKT":"WKT"})
+
+            except Exception as e:
+                print(f"Vector creation raises an exception: {exc}")
 
         Raises:
             MissingEnvironmentError: Missing object storage informations
@@ -44,55 +58,13 @@ def __init__(self, path: str, delimiter: str = ";", column_x : str = "x" , colum
 
         """
 
+        self = cls()
+
         self.path = path
 
         path_split = path.split("/")
 
-        if path.endswith(".csv") :
-
-            data = get_data_str(path)
-            data = data.split("\n")
-            for i in range (len(data)) :
-                data[i] = data[i].split(delimiter)
-
-            attributes = []
-            for i in range (len(data[0])) :
-                attributes += [(data[0][i] , "String")]
-            layers = [(path_split[-1][:-4], len(data)-1, attributes)]
-            self.layers = layers
-
-            geomcol = ogr.Geometry(ogr.wkbGeometryCollection)
-            if column_WKT == None :
-                try :
-                    data_x = data[0].index(column_x)
-                except :
-                    raise Exception(f"{column_x} is not a column of the CSV")
-
-                try :
-                    data_y = data[0].index(column_y)
-                except :
-                    raise Exception(f"{column_y} is not a column of the CSV")
-
-                for i in range (1, len(data)) :
-                    point = ogr.Geometry(ogr.wkbPoint)
-                    try :
-                        point.AddPoint(float(data[i][data_x]), float(data[i][data_y]))
-                    except :
-                        raise Exception(f"{column_x} or {column_y} contains data which are not coordinates")
-                    geomcol.AddGeometry(point)
-
-            else :
-                data_WKT = data[0].index(column_WKT)
-                for i in range (1, len(data)) :
-                    try :
-                        geom = ogr.CreateGeometryFromWkt(data[i][data_WKT])
-                    except :
-                        raise Exception(f"{column_WKT} contains data which are not WKT")
-                    geomcol.AddGeometry(geom)
-
-            self.bbox = geomcol.GetEnvelope()
-
-        else :
+        if path_split[0] == "ceph:" or path.endswith(".csv"):
 
             if path.endswith(".shp") :
                 with tempfile.TemporaryDirectory() as tmp :
@@ -122,32 +94,115 @@ def __init__(self, path: str, delimiter: str = ";", column_x : str = "x" , colum
 
                     dataSource = ogr.Open(tmp_path + ".geojson", 0)
 
+            elif path.endswith(".csv") :
+                # Récupération des informations optionnelles
+                if "CSV" in kwargs :
+                    csv = kwargs["CSV"]
+                else :
+                    csv = {}
+
+                if "srs" in csv and csv["srs"] is not None :
+                    srs = csv["srs"]
+                else :
+                    srs = "EPSG:2154"
+
+                if "column_x" in csv and csv["column_x"] is not None :
+                    column_x = csv["column_x"]
+                else :
+                    column_x = "x"
+
+                if "column_y" in csv and csv["column_y"] is not None :
+                    column_y = csv["column_y"]
+                else :
+                    column_y = "y"
+
+                if "column_WKT" in csv :
+                    column_WKT = csv["column_WKT"]
+                else :
+                    column_WKT = None
+
+                with tempfile.TemporaryDirectory() as tmp :
+                    tmp_path = tmp + "/" + path_split[-1][:-4]
+                    name_fich = path_split[-1][:-4]
+
+                    copy(path, "file://" + tmp_path + ".csv")
+
+                    with tempfile.NamedTemporaryFile(mode='w', suffix=".vrt", dir=tmp, delete=False) as tmp2 :
+                        vrt_file = "<OGRVRTDataSource>\n"
+                        vrt_file += '<OGRVRTLayer name="' + name_fich + '">\n'
+                        vrt_file += "<SrcDataSource>" + tmp_path + ".csv</SrcDataSource>\n"
+                        vrt_file += "<SrcLayer>" + name_fich + "</SrcLayer>\n"
+                        vrt_file += "<LayerSRS>" + srs + "</LayerSRS>\n"
+                        if column_WKT == None :
+                            vrt_file += '<GeometryField encoding="PointFromColumns" x="' + column_x + '" y="' + column_y + '"/>\n'
+                        else :
+                            vrt_file += '<GeometryField encoding="WKT" field="' + column_WKT + '"/>\n'
+                        vrt_file += "</OGRVRTLayer>\n"
+                        vrt_file += "</OGRVRTDataSource>"
+                        tmp2.write(vrt_file)
+                    copy("file://"+tmp2.name, "/home/CPeutin/Workplace/test.vrt")
+                    dataSourceVRT = ogr.Open(tmp2.name, 0)
+                    os.remove(tmp2.name)
+                    dataSource=ogr.GetDriverByName("ESRI Shapefile").CopyDataSource(dataSourceVRT, tmp_path + "shp")
+
             else :
                 raise Exception("This format of file cannot be loaded")
 
-            multipolygon = ogr.Geometry(ogr.wkbGeometryCollection)
+        else :
+            dataSource = ogr.Open(get_osgeo_path(path), 0)
+
+        multipolygon = ogr.Geometry(ogr.wkbGeometryCollection)
+        try :
+            layer = dataSource.GetLayer()
+        except AttributeError :
+            raise Exception(f"The content of {self.path} cannot be read")
+
+        layers = []
+        for i in range (dataSource.GetLayerCount()) :
+            layer = dataSource.GetLayer(i)
+            name = layer.GetName()
+            count = layer.GetFeatureCount()
+            layerDefinition = layer.GetLayerDefn()
+            attributes = []
+            for j in range(layerDefinition.GetFieldCount()):
+                fieldName =  layerDefinition.GetFieldDefn(j).GetName()
+                fieldTypeCode = layerDefinition.GetFieldDefn(j).GetType()
+                fieldType = layerDefinition.GetFieldDefn(j).GetFieldTypeName(fieldTypeCode)
+                attributes += [(fieldName, fieldType)]
+            for feature in layer :
+                geom = feature.GetGeometryRef()
+                if geom != None :
+                    multipolygon.AddGeometry(geom)
+            layers += [(name, count, attributes)]
+
+        self.layers = layers
+        self.bbox = multipolygon.GetEnvelope()
+
+        return self
+
+    @classmethod
+    def from_parameters(cls, path: str, bbox : tuple, layers : list) -> 'Vector' :
+        """Constructor method of a Vector from a parameters
+
+        Args:
+            path (str): path to the file/object
+            bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
+            layers (List[Tuple[str, int, List[Tuple[str, str]]]]) : Vector layers with their name, their number of objects and their attributes
+
+        Examples:
+
             try :
-                layer = dataSource.GetLayer()
-            except AttributeError :
-                raise Exception(f"The content of {self.path} cannot be read")
-
-            layers = []
-            for i in range (dataSource.GetLayerCount()) :
-                layer = dataSource.GetLayer(i)
-                name = layer.GetName()
-                count = layer.GetFeatureCount()
-                layerDefinition = layer.GetLayerDefn()
-                attributes = []
-                for i in range(layerDefinition.GetFieldCount()):
-                    fieldName =  layerDefinition.GetFieldDefn(i).GetName()
-                    fieldTypeCode = layerDefinition.GetFieldDefn(i).GetType()
-                    fieldType = layerDefinition.GetFieldDefn(i).GetFieldTypeName(fieldTypeCode)
-                    attributes += [(fieldName, fieldType)]
-                for feature in layer :
-                    geom = feature.GetGeometryRef()
-                    if geom != None :
-                        multipolygon.AddGeometry(geom)
-                layers += [(name, count, attributes)]
-
-            self.layers = layers
-            self.bbox = multipolygon.GetEnvelope()
+                vector = Vector.from_parameters("file://tests/fixtures/ARRONDISSEMENT.shp", (1,2,3,4), [('ARRONDISSEMENT', 14, [('ID', 'String'), ('NOM', 'String'), ('INSEE_ARR', 'String'), ('INSEE_DEP', 'String'), ('INSEE_REG', 'String'), ('ID_AUT_ADM', 'String'), ('DATE_CREAT', 'String'), ('DATE_MAJ', 'String'), ('DATE_APP', 'Date'), ('DATE_CONF', 'Date')])])
+
+            except Exception as e:
+                print(f"Vector creation raises an exception: {exc}")
+
+        """
+
+        self = cls()
+
+        self.path = path
+        self.bbox = bbox
+        self.layers = layers
+
+        return self
diff --git a/tests/fixtures/vector.csv b/tests/fixtures/vector.csv
new file mode 100644
index 0000000..e4747c6
--- /dev/null
+++ b/tests/fixtures/vector.csv
@@ -0,0 +1,4 @@
+id;x;y
+1;20000;50000
+2;1000;2
+3;500000;5
diff --git a/tests/fixtures/vector2.csv b/tests/fixtures/vector2.csv
new file mode 100644
index 0000000..0efe2fd
--- /dev/null
+++ b/tests/fixtures/vector2.csv
@@ -0,0 +1,2 @@
+id;WKT
+1;POINT(1 1)
diff --git a/tests/test_Vector.py b/tests/test_Vector.py
index a83f429..b7dd8c7 100644
--- a/tests/test_Vector.py
+++ b/tests/test_Vector.py
@@ -5,7 +5,7 @@
 
 @author: cpeutin
 """
-from rok4.Vector import Vector
+from rok4.Vector import *
 from rok4.Exceptions import *
 from rok4.Storage import disconnect_ceph_clients
 
@@ -19,88 +19,69 @@
 def test_missing_env():
     disconnect_ceph_clients()
     with pytest.raises(MissingEnvironmentError):
-        vector = Vector("ceph:///ign_std/vector.shp")
+        vector = Vector.from_file("ceph:///ign_std/vector.shp")
 
-@mock.patch('rok4.Vector.copy', side_effect=StorageError('FILE', 'Not found'))
+@mock.patch('rok4.Vector.copy', side_effect=StorageError('CEPH', 'Not found'))
 def test_wrong_file(mocked_copy):
     with pytest.raises(StorageError):
-        vector = Vector("file:///vector.shp")
-
-@mock.patch('rok4.Vector.get_data_str', return_value="x1;y1\n no_coor;no_coor")
-def test_wrong_column_point1(mocked_get_data_str):
-    with pytest.raises(Exception) as exc:
-        vector = Vector("file:///vector.csv" , ";", "x", "y")
-    assert str(exc.value) == "x is not a column of the CSV"
-    mocked_get_data_str.assert_called_once_with("file:///vector.csv")
-
-@mock.patch('rok4.Vector.get_data_str', return_value="x;y1\n no_coor;no_coor")
-def test_wrong_column_point2(mocked_get_data_str):
-    with pytest.raises(Exception) as exc:
-        vector = Vector("file:///vector.csv" , ";", "x", "y")
-    assert str(exc.value) == "y is not a column of the CSV"
-    mocked_get_data_str.assert_called_once_with("file:///vector.csv")
-
-@mock.patch('rok4.Vector.get_data_str', return_value="x;y\n no_coor;no_coor")
-def test_wrong_data_column_point(mocked_get_data_str):
-    with pytest.raises(Exception) as exc:
-        vector = Vector("file:///vector.csv" , ";", "x", "y")
-    assert str(exc.value) == "x or y contains data which are not coordinates"
-    mocked_get_data_str.assert_called_once_with("file:///vector.csv")
-
-@mock.patch('rok4.Vector.get_data_str', return_value="WKT\n no_coor")
-def test_wrong_data_column_WKT(mocked_get_data_str):
-    with pytest.raises(Exception) as exc:
-        vector = Vector("file:///vector.csv" , ";", column_WKT="WKT")
-    assert str(exc.value) == "WKT contains data which are not WKT"
-    mocked_get_data_str.assert_called_once_with("file:///vector.csv")
+        vector = Vector.from_file("ceph:///vector.geojson")
 
 def test_wrong_format():
     with pytest.raises(Exception) as exc:
-        vector = Vector("file:///vector.tif")
+        vector = Vector.from_file("ceph:///vector.tif")
     assert str(exc.value) == "This format of file cannot be loaded"
 
+@mock.patch('rok4.Vector.ogr.Open', return_value="not a shape")
+def test_wrong_content(mocked_copy):
+    with pytest.raises(Exception) as exc:
+        vector = Vector.from_file("file:///vector.shp")
+    assert str(exc.value) == "The content of file:///vector.shp cannot be read"
+
 @mock.patch('rok4.Vector.copy')
 @mock.patch('rok4.Vector.ogr.Open', return_value="not a shape")
-def test_wrong_content(mocked_open, mocked_copy):
+def test_wrong_content_ceph(mocked_open, mocked_copy):
     with pytest.raises(Exception) as exc:
-        vector = Vector("file:///vector.shp")
+        vector = Vector.from_file("file:///vector.shp")
     assert str(exc.value) == "The content of file:///vector.shp cannot be read"
 
-@mock.patch('rok4.Vector.get_data_str', return_value="id;x;y\n 1;20000;50000")
-def test_ok_csv1(mocked_get_data_str) :
+def test_ok_csv1() :
     try :
-        vector_csv1 = Vector("file:///vector.csv" , ";", "x", "y")
-        assert str(vector_csv1.layers) == "[('vector', 1, [('id', 'String'), ('x', 'String'), ('y', 'String')])]"
-        mocked_get_data_str.assert_called_once_with("file:///vector.csv")
+        vector_csv1 = Vector.from_file("file://tests/fixtures/vector.csv" , CSV={"delimiter":";", "column_x":"x", "column_y":"y"})
+        assert str(vector_csv1.layers) == "[('vector', 3, [('id', 'String'), ('x', 'String'), ('y', 'String')])]"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
-@mock.patch('rok4.Vector.get_data_str', return_value="id;WKT\n 1;POINT(1 1)")
-def test_ok_csv2(mocked_get_data_str) :
+def test_ok_csv2() :
     try :
-        vector_csv2 = Vector("file:///vector.csv" , ";", column_WKT="WKT")
-        assert str(vector_csv2.layers) == "[('vector', 1, [('id', 'String'), ('WKT', 'String')])]"
-        mocked_get_data_str.assert_called_once_with("file:///vector.csv")
+        vector_csv2 = Vector.from_file("file://tests/fixtures/vector2.csv" , CSV={"delimiter":";", "column_WKT":"WKT"})
+        assert str(vector_csv2.layers) == "[('vector2', 1, [('id', 'String'), ('WKT', 'String')])]"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
 def test_ok_geojson() :
     try :
-        vector = Vector("file://tests/fixtures/vector.geojson")
+        vector = Vector.from_file("file://tests/fixtures/vector.geojson")
         assert str(vector.layers) == "[('vector', 1, [('id', 'String'), ('id_fantoir', 'String'), ('numero', 'Integer'), ('rep', 'String'), ('nom_voie', 'String'), ('code_postal', 'Integer'), ('code_insee', 'Integer'), ('nom_commune', 'String'), ('code_insee_ancienne_commune', 'String'), ('nom_ancienne_commune', 'String'), ('x', 'Real'), ('y', 'Real'), ('lon', 'Real'), ('lat', 'Real'), ('type_position', 'String'), ('alias', 'String'), ('nom_ld', 'String'), ('libelle_acheminement', 'String'), ('nom_afnor', 'String'), ('source_position', 'String'), ('source_nom_voie', 'String'), ('certification_commune', 'Integer'), ('cad_parcelles', 'String')])]"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
 def test_ok_gpkg() :
     try :
-        vector = Vector("file://tests/fixtures/vector.gpkg")
+        vector = Vector.from_file("file://tests/fixtures/vector.gpkg")
         assert str(vector.layers) == "[('Table1', 2, [('id', 'String')]), ('Table2', 2, [('id', 'Integer'), ('nom', 'String')])]"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
 def test_ok_shp() :
     try :
-        vector = Vector("file://tests/fixtures/ARRONDISSEMENT.shp")
+        vector = Vector.from_file("file://tests/fixtures/ARRONDISSEMENT.shp")
         assert str(vector.layers) == "[('ARRONDISSEMENT', 14, [('ID', 'String'), ('NOM', 'String'), ('INSEE_ARR', 'String'), ('INSEE_DEP', 'String'), ('INSEE_REG', 'String'), ('ID_AUT_ADM', 'String'), ('DATE_CREAT', 'String'), ('DATE_MAJ', 'String'), ('DATE_APP', 'Date'), ('DATE_CONF', 'Date')])]"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
+
+def test_ok_parameters() :
+    try :
+        vector = Vector.from_parameters("file://tests/fixtures/ARRONDISSEMENT.shp", (1,2,3,4), [('ARRONDISSEMENT', 14, [('ID', 'String'), ('NOM', 'String'), ('INSEE_ARR', 'String'), ('INSEE_DEP', 'String'), ('INSEE_REG', 'String'), ('ID_AUT_ADM', 'String'), ('DATE_CREAT', 'String'), ('DATE_MAJ', 'String'), ('DATE_APP', 'Date'), ('DATE_CONF', 'Date')])])
+        assert str(vector.path) == "file://tests/fixtures/ARRONDISSEMENT.shp"
+    except Exception as exc:
+        assert False, f"Vector creation raises an exception: {exc}"

From 0bd4ade987b29769368513ab02d588f6e88c613b Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Tue, 11 Apr 2023 15:37:06 +0200
Subject: [PATCH 18/89] Suppression messages inutiles

---
 tests/test_Vector.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/tests/test_Vector.py b/tests/test_Vector.py
index b7dd8c7..495b32e 100644
--- a/tests/test_Vector.py
+++ b/tests/test_Vector.py
@@ -1,10 +1,5 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""
-Created on Wed Jan 18 12:04:07 2023
-
-@author: cpeutin
-"""
 from rok4.Vector import *
 from rok4.Exceptions import *
 from rok4.Storage import disconnect_ceph_clients

From d696ebde12584561221ae68f8bb3d717d8c0ae1c Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Tue, 11 Apr 2023 16:03:24 +0200
Subject: [PATCH 19/89] =?UTF-8?q?Mise=20=C3=A0=20jour=20Changelog?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a24c5b..0e87fa8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,7 @@
 ## Summary
 
 Lecture facilitée de la liste d'une pyramide.
+Modification de la gestion des vecteurs
 
 ## Changelog
 
@@ -11,6 +12,15 @@ Lecture facilitée de la liste d'une pyramide.
     * 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
+
+### [Changed]
+
+* Vector
+    * Utilisation de kwargs pour les paramètres du csv
+    * Gestion des CSV par OGR
+    * Passage par get_osgeo_path pour la lecture virtuelle
+    * 2 constructeurs pour les vecteurs : from_file et from_parameters
+
 ### [Fixed]
 
 * Storage

From 67efd52a1b4ef13ce5fdf9f443085875455b348b Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Wed, 12 Apr 2023 15:46:32 +0200
Subject: [PATCH 20/89] =?UTF-8?q?Retrait=20de=20l'utilisation=20de=20kwarg?=
 =?UTF-8?q?s=20pour=20des=20param=C3=A8tres=20obligatoires=20dans=20la=20f?=
 =?UTF-8?q?onction=20`Raster.from=5Fparameters()`.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Raster.py | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 1d20fd6..7c5d955 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -10,6 +10,7 @@
 from enum import Enum
 
 from osgeo import ogr, gdal
+from typing import Tuple
 
 from rok4.Storage import exists, get_osgeo_path
 from rok4.Utils import ColorFormat, compute_bbox,compute_format
@@ -96,16 +97,16 @@ def from_file(cls, path: str) -> 'Raster':
         return self
 
     @classmethod
-    def from_parameters(cls, mask: str = None, **kwargs) -> 'Raster':
-        """Creates a Raster object from key/value parameters
+    def from_parameters(cls, path: str, bands: int, bbox: Tuple[float, float, float, float], dimensions: Tuple[int, int], format: ColorFormat, mask: str = None) -> 'Raster':
+        """Creates a Raster object from parameters
 
         Args:
-            **mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
-            **path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
-            **bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
-            **bands (int): number of color bands (or channels)
-            **format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
-            **dimensions (Tuple[int, int]): image width and height expressed in pixels
+            path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
+            bands (int): number of color bands (or channels)
+            bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
+            dimensions (Tuple[int, int]): image width and height expressed in pixels
+            format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
+            mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
 
         Examples:
 
@@ -128,11 +129,11 @@ def from_parameters(cls, mask: str = None, **kwargs) -> 'Raster':
 
         self = cls()
             
-        self.path = kwargs["path"]
+        self.path = path
+        self.bands = bands
+        self.bbox = bbox
+        self.dimensions = dimensions
+        self.format = format
         self.mask = mask
-        self.bbox = kwargs["bbox"]
-        self.bands = kwargs["bands"]
-        self.format = kwargs["format"]
-        self.dimensions = kwargs["dimensions"]
 
         return self

From 9336da29280cdd50b7a1f04de33994a3409ac0d3 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Thu, 13 Apr 2023 14:17:49 +0200
Subject: [PATCH 21/89] Modifcation du get_infos_from path pour HTTP +
 modifications mineurs pour le HTTP

---
 src/rok4/Storage.py   | 37 ++++++++++++++++++++-----------------
 tests/test_Storage.py |  7 ++++++-
 2 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index 0f12a62..d19d437 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -207,9 +207,9 @@ def get_infos_from_path(path: str) -> Tuple[StorageType, str, str, str]:
     elif path.startswith("file://"):
         return StorageType.FILE, path[7:], os.path.dirname(path[7:]), os.path.basename(path[7:])
     elif path.startswith("http://"):
-        return StorageType.HTTP, path, "NULL", "NULL"
+        return StorageType.HTTP, path[7:], os.path.dirname(path[7:]), os.path.basename(path[7:])
     elif path.startswith("https://"):
-        return StorageType.HTTPS, path, "NULL", "NULL"
+        return StorageType.HTTPS, path[8:], os.path.dirname(path[8:]), os.path.basename(path[8:])
     else:
         return StorageType.FILE, path, os.path.dirname(path), os.path.basename(path)
 
@@ -347,14 +347,16 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
 
-        try:
-            reponse = requests.get(path, stream=True)
-            data = reponse.content
-            print(reponse.content)
-            if reponse.status_code == 404 :
-                raise StorageError("HTTP", "Requested file does not exist")
-        except Exception as e:
-            raise StorageError("HTTP", e)
+        if range is None :
+            try:
+                reponse = requests.get(storage_type.value + path, stream=True)
+                data = reponse.content
+                if reponse.status_code == 404 :
+                    raise StorageError(storage_type.name, "Requested file does not exist")
+            except Exception as e:
+                raise StorageError(storage_type.name, e)
+        else :
+            raise NotImplementedError
 
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to read binary data")
@@ -459,10 +461,11 @@ def get_size(path: str) -> int:
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
 
         try:
-            reponse = requests.get(path, stream=True)
-            return reponse.content.__sizeof__()
+            # Le stream=True permet de ne télécharger que le header initialement
+            reponse = requests.get(storage_type.value + path, stream=True).headers["content-length"]
+            return reponse
         except Exception as e:
-            raise StorageError("HTTP", e)
+            raise StorageError(storage_type.name, e)
 
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to get size")
@@ -516,7 +519,7 @@ def exists(path: str) -> bool:
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
 
         try:
-            reponse = requests.get(path, stream=True)
+            reponse = requests.get(storage_type.value + path, stream=True)
             if reponse.status_code == 200 :
                 return True
             else :
@@ -810,7 +813,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
     elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.FILE :
 
         try:
-            reponse = requests.get(from_path, stream = True)
+            reponse = requests.get(from_type.value + from_path, stream = True)
             with open(to_path, "wb") as f:
                 for chunk in reponse.iter_content(chunk_size=65536) :
                     if chunk:
@@ -824,7 +827,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
-            reponse = requests.get(from_path, stream = True)
+            reponse = requests.get(from_type.value + from_path, stream = True)
             offset = 0
             for chunk in reponse.iter_content(chunk_size=65536) :
                 if chunk:
@@ -840,7 +843,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            reponse = requests.get(from_path, stream = True)
+            reponse = requests.get(from_type.value + from_path, stream = True)
             with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
                 name_fich = f.name
                 for chunk in reponse.iter_content(chunk_size=65536) :
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index d1de8b5..07006e6 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -140,6 +140,11 @@ def test_http_read_error(mock_http):
 
     mock_http.assert_called_with("http:///path/to/file.ext", stream=True)
 
+@mock.patch.dict(os.environ, {}, clear=True)
+def test_http_read_range_error():
+    with pytest.raises(NotImplementedError):
+        data = get_data_binary("http:///path/to/file.ext", (0,100))
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("requests.get")
 def test_http_read_ok(mock_http):
@@ -581,7 +586,7 @@ def test_size_s3_ok(mocked_s3_client):
 def test_size_http_ok(mock_requests):
 
     http_instance = MagicMock()
-    http_instance.content.__sizeof__.return_value = 12
+    http_instance.headers = {"content-length":12}
     mock_requests.return_value = http_instance
 
     try:

From c6b0d97dbfb2590e55b685b9a4086317397a9986 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Mon, 17 Apr 2023 14:27:40 +0200
Subject: [PATCH 22/89] Suppression ligne de tests

---
 src/rok4/Vector.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/rok4/Vector.py b/src/rok4/Vector.py
index 1c712dd..524f3dc 100644
--- a/src/rok4/Vector.py
+++ b/src/rok4/Vector.py
@@ -140,7 +140,6 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
                         vrt_file += "</OGRVRTLayer>\n"
                         vrt_file += "</OGRVRTDataSource>"
                         tmp2.write(vrt_file)
-                    copy("file://"+tmp2.name, "/home/CPeutin/Workplace/test.vrt")
                     dataSourceVRT = ogr.Open(tmp2.name, 0)
                     os.remove(tmp2.name)
                     dataSource=ogr.GetDriverByName("ESRI Shapefile").CopyDataSource(dataSourceVRT, tmp_path + "shp")

From d043916019738d8de3022e5b0ff382af0c0e5ba6 Mon Sep 17 00:00:00 2001
From: CorentinPeutin <corentin.peutin@ensg.eu>
Date: Mon, 17 Apr 2023 16:31:43 +0200
Subject: [PATCH 23/89] Correction de coquilles

---
 src/rok4/Storage.py   | 10 +++++-----
 tests/test_Storage.py | 28 ++++++++++++++--------------
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index d19d437..b938670 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -2,10 +2,10 @@
 
 Available storage types are :
 - S3 (path are preffixed with `s3://`)
-- CEPH (path are preffixed with `ceph://`)
-- FILE (path are preffixed with `file://`, but it is the default paths' interpretation)
-- HTTP (path are preffixed with `https://`)
-- HTTPS (path are preffixed with `https://`)
+- CEPH (path are prefixed with `ceph://`)
+- FILE (path are prefixed with `file://`, but it is the default paths' interpretation)
+- HTTP (path are prefixed with `http://`)
+- HTTPS (path are prefixed with `https://`)
 
 According to functions, all storage types are not necessarily available.
 
@@ -525,7 +525,7 @@ def exists(path: str) -> bool:
             else :
                 return False
         except Exception as e:
-            raise StorageError("HTTP", e)
+            raise StorageError(storage_type.name, e)
 
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to test if exists")
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 07006e6..d0ca499 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -136,14 +136,14 @@ def test_http_read_error(mock_http):
         requests_instance.content = "NULL"
         requests_instance.status_code = 404
         mock_http.return_value = requests_instance
-        data = get_data_str("http:///path/to/file.ext")
+        data = get_data_str("http://path/to/file.ext")
 
-    mock_http.assert_called_with("http:///path/to/file.ext", stream=True)
+    mock_http.assert_called_with("http://path/to/file.ext", stream=True)
 
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_http_read_range_error():
     with pytest.raises(NotImplementedError):
-        data = get_data_binary("http:///path/to/file.ext", (0,100))
+        data = get_data_binary("http://path/to/file.ext", (0,100))
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("requests.get")
@@ -153,8 +153,8 @@ def test_http_read_ok(mock_http):
         requests_instance.content = b'data'
         mock_http.return_value = requests_instance
 
-        data = get_data_str("http:///path/to/file.ext")
-        mock_http.assert_called_with("http:///path/to/file.ext", stream=True)
+        data = get_data_str("http://path/to/file.ext")
+        mock_http.assert_called_with("http://path/to/file.ext", stream=True)
         assert data == 'data'
     except Exception as exc:
         assert False, f"HTTP read raises an exception: {exc}"
@@ -408,8 +408,8 @@ def test_copy_http_file_ok(mock_open, mock_requests):
         http_instance.iter_content.return_value = ["data","data2"]
         mock_requests.return_value = http_instance
 
-        copy("http:///path/to/source.ext", "file:///path/to/destination.ext")
-        mock_requests.assert_called_once_with("http:///path/to/source.ext", stream=True)
+        copy("http://path/to/source.ext", "file:///path/to/destination.ext")
+        mock_requests.assert_called_once_with("http://path/to/source.ext", stream=True)
         mock_open.assert_called_once_with("/path/to/destination.ext", "wb")
     except Exception as exc:
         assert False, f"HTTP -> FILE copy raises an exception: {exc}"
@@ -432,8 +432,8 @@ def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
         ceph_instance.open_ioctx.return_value = ioctx_instance
         mocked_rados_client.return_value = ceph_instance
 
-        copy("http:///path/to/source.ext", "ceph://pool1/source.ext")
-        mock_requests.assert_called_once_with("http:///path/to/source.ext", stream=True)
+        copy("http://path/to/source.ext", "ceph://pool1/source.ext")
+        mock_requests.assert_called_once_with("http://path/to/source.ext", stream=True)
     except Exception as exc:
         assert False, f"HTTP -> CEPH copy raises an exception: {exc}"
 
@@ -455,8 +455,8 @@ def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_cl
         s3_instance.head_object.return_value = {"ETag": "8d777f385d3dfec8815d20f7496026dc"}
         mocked_s3_client.return_value = s3_instance
 
-        copy("http:///path/to/source.ext", "s3://bucket/destination.ext")
-        mock_requests.assert_called_once_with("http:///path/to/source.ext", stream=True)
+        copy("http://path/to/source.ext", "s3://bucket/destination.ext")
+        mock_requests.assert_called_once_with("http://path/to/source.ext", stream=True)
         mock_tempfile.assert_called_once_with("w+b",delete=False)
     except Exception as exc:
         assert False, f"HTTP -> CEPH copy raises an exception: {exc}"
@@ -590,7 +590,7 @@ def test_size_http_ok(mock_requests):
     mock_requests.return_value = http_instance
 
     try:
-        size = get_size("http:///path/to/file.ext")
+        size = get_size("http://path/to/file.ext")
         assert size == 12
     except Exception as exc:
         assert False, f"HTTP size raises an exception: {exc}"
@@ -664,7 +664,7 @@ def test_exists_http_ok(mock_requests):
     mock_requests.return_value = http_instance
 
     try:
-        assert exists("http:///path/to/file.ext")
+        assert exists("http://path/to/file.ext")
     except Exception as exc:
         assert False, f"HTTP exists raises an exception: {exc}"
 
@@ -672,7 +672,7 @@ def test_exists_http_ok(mock_requests):
     mock_requests.return_value = http_instance
 
     try:
-        assert not exists("http:///path/to/file.ext")
+        assert not exists("http://path/to/file.ext")
     except Exception as exc:
         assert False, f"HTTP exists raises an exception: {exc}"
 

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 24/89] 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 25/89] =?UTF-8?q?Erreur=20de=20copier-coller=20corrig?=
 =?UTF-8?q?=C3=A9=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 9a616e10225bd659a73f5ced8b1e9c2f43f4b678 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Th=C3=A9o=20Satabin?= <theo.satabin@ign.fr>
Date: Wed, 3 May 2023 17:10:49 +0200
Subject: [PATCH 26/89] Utilisation de GDAL avec exception

---
 src/rok4/Utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 548f5f7..47e1bcd 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -10,6 +10,7 @@
 
 ogr.UseExceptions()
 osr.UseExceptions()
+gdal.UseExceptions()
 
 
 class ColorFormat(Enum):
@@ -263,4 +264,4 @@ def compute_format(dataset: gdal.Dataset, path: str = None) -> 'ColorFormat':
     else:
         raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
 
-    return format
\ No newline at end of file
+    return format

From 818e7e4c188d31ec5ffb558afa8bb3543d4e472a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Th=C3=A9o=20Satabin?= <theo.satabin@ign.fr>
Date: Wed, 3 May 2023 17:12:00 +0200
Subject: [PATCH 27/89] Utilisation de GDAL avec exception

---
 src/rok4/Raster.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 7c5d955..2a06ee6 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -17,7 +17,7 @@
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
-
+gdal.UseExceptions()
 
 class Raster:
     """A structure describing raster data

From 9850a56a62c8867aab394474dff2c7e7b0b8ca34 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Wed, 3 May 2023 17:55:36 +0200
Subject: [PATCH 28/89] =?UTF-8?q?Remise=20du=20CHANGELOG=20=C3=A9cras?=
 =?UTF-8?q?=C3=A9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CHANGELOG.md        | 14 +++++++++++++-
 src/rok4/Pyramid.py |  2 --
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e93aeb8..23fc847 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 ## Summary
 
-Lecture d'informations sur une donnée raster unique depuis un fichier ou une liste de paramètres.
+Lecture facilitée de la liste d'une pyramide. Lecture d'informations sur une donnée raster unique depuis un fichier ou une liste de paramètres.
 
 ## Changelog
 
@@ -13,6 +13,12 @@ Lecture d'informations sur une donnée raster unique depuis un fichier ou une li
     * Tests unitaires
     * Documentation interne des fonctions et classes
 
+* 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
+
 ### [Changed]
 
 * README.md
@@ -21,6 +27,12 @@ Lecture d'informations sur une donnée raster unique depuis un fichier ou une li
     * Fonction de calcul de la boundix box d'une donnée
     * Fonction de détermination du format de variable des couleurs dans une donéne raster
 
+
+### [Fixed]
+
+* Storage
+    * Lecture de la taille d'un objet S3 : pas besoin d'enlever des quotes dans le header `Content-Length`
+
 <!--
 ### [Added]
 
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 6263aaf..ab0a885 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -286,9 +286,7 @@ def bbox(self) -> Tuple[float, float, float, float]:
             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"])
-        print(max_bbox)
 
         return (min_bbox[0], min_bbox[1], max_bbox[2], max_bbox[3])
 

From 8f33d9dc3c699b421060c9f5c7335c9e5a0e7a3f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Th=C3=A9o=20Satabin?= <theo.satabin@ign.fr>
Date: Thu, 4 May 2023 11:47:48 +0200
Subject: [PATCH 29/89] =?UTF-8?q?Passage=20en=20minuscule=20des=20noms=20d?=
 =?UTF-8?q?es=20param=C3=A8tres?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Vector.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/rok4/Vector.py b/src/rok4/Vector.py
index 524f3dc..9cb8c00 100644
--- a/src/rok4/Vector.py
+++ b/src/rok4/Vector.py
@@ -30,11 +30,11 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
 
         Args:
             path (str): path to the file/object
-            **CSV (Dict[str : str]) : dictionnary of CSV parameters :
+            **csv (Dict[str : str]) : dictionnary of CSV parameters :
                 -srs (str) ("EPSG:2154" if not provided) : spatial reference system of the geometry
                 -column_x (str) ("x" if not provided) : field of the x coordinate
                 -column_y (str) ("y" if not provided) : field of the y coordinate
-                -column_WKT (str) (None if not provided) : field of the WKT of the geometry if WKT use to define coordinate
+                -column_wkt (str) (None if not provided) : field of the WKT of the geometry if WKT use to define coordinate
 
         Examples:
 
@@ -42,8 +42,8 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
 
             try:
                 vector = Vector.from_file("file://tests/fixtures/ARRONDISSEMENT.shp")
-                vector_csv1 = Vector.from_file("file://tests/fixtures/vector.csv" , CSV={"delimiter":";", "column_x":"x", "column_y":"y"})
-                vector_csv2 = Vector.from_file("file://tests/fixtures/vector2.csv" , CSV={"delimiter":";", "column_WKT":"WKT"})
+                vector_csv1 = Vector.from_file("file://tests/fixtures/vector.csv" , csv={"delimiter":";", "column_x":"x", "column_y":"y"})
+                vector_csv2 = Vector.from_file("file://tests/fixtures/vector2.csv" , csv={"delimiter":";", "column_wkt":"WKT"})
 
             except Exception as e:
                 print(f"Vector creation raises an exception: {exc}")
@@ -96,8 +96,8 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
 
             elif path.endswith(".csv") :
                 # Récupération des informations optionnelles
-                if "CSV" in kwargs :
-                    csv = kwargs["CSV"]
+                if "csv" in kwargs :
+                    csv = kwargs["csv"]
                 else :
                     csv = {}
 
@@ -116,10 +116,10 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
                 else :
                     column_y = "y"
 
-                if "column_WKT" in csv :
-                    column_WKT = csv["column_WKT"]
+                if "column_wkt" in csv :
+                    column_wkt = csv["column_wkt"]
                 else :
-                    column_WKT = None
+                    column_wkt = None
 
                 with tempfile.TemporaryDirectory() as tmp :
                     tmp_path = tmp + "/" + path_split[-1][:-4]
@@ -133,10 +133,10 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
                         vrt_file += "<SrcDataSource>" + tmp_path + ".csv</SrcDataSource>\n"
                         vrt_file += "<SrcLayer>" + name_fich + "</SrcLayer>\n"
                         vrt_file += "<LayerSRS>" + srs + "</LayerSRS>\n"
-                        if column_WKT == None :
+                        if column_wkt == None :
                             vrt_file += '<GeometryField encoding="PointFromColumns" x="' + column_x + '" y="' + column_y + '"/>\n'
                         else :
-                            vrt_file += '<GeometryField encoding="WKT" field="' + column_WKT + '"/>\n'
+                            vrt_file += '<GeometryField encoding="WKT" field="' + column_wkt + '"/>\n'
                         vrt_file += "</OGRVRTLayer>\n"
                         vrt_file += "</OGRVRTDataSource>"
                         tmp2.write(vrt_file)

From a32d0ba75ca4fafdc764e7821edd6bd46176ff03 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Th=C3=A9o=20Satabin?= <theo.satabin@ign.fr>
Date: Thu, 4 May 2023 11:48:59 +0200
Subject: [PATCH 30/89] =?UTF-8?q?Passage=20en=20minuscule=20des=20param?=
 =?UTF-8?q?=C3=A8tres=20CSV?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_Vector.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_Vector.py b/tests/test_Vector.py
index 495b32e..c7eb2e4 100644
--- a/tests/test_Vector.py
+++ b/tests/test_Vector.py
@@ -41,14 +41,14 @@ def test_wrong_content_ceph(mocked_open, mocked_copy):
 
 def test_ok_csv1() :
     try :
-        vector_csv1 = Vector.from_file("file://tests/fixtures/vector.csv" , CSV={"delimiter":";", "column_x":"x", "column_y":"y"})
+        vector_csv1 = Vector.from_file("file://tests/fixtures/vector.csv" , csv={"delimiter":";", "column_x":"x", "column_y":"y"})
         assert str(vector_csv1.layers) == "[('vector', 3, [('id', 'String'), ('x', 'String'), ('y', 'String')])]"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
 def test_ok_csv2() :
     try :
-        vector_csv2 = Vector.from_file("file://tests/fixtures/vector2.csv" , CSV={"delimiter":";", "column_WKT":"WKT"})
+        vector_csv2 = Vector.from_file("file://tests/fixtures/vector2.csv" , csv={"delimiter":";", "column_wkt":"WKT"})
         assert str(vector_csv2.layers) == "[('vector2', 1, [('id', 'String'), ('WKT', 'String')])]"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"

From 6efe37ae3b344a8263d9eec3d92e455c89b1732a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Th=C3=A9o=20Satabin?= <theo.satabin@ign.fr>
Date: Thu, 4 May 2023 13:41:37 +0200
Subject: [PATCH 31/89] =?UTF-8?q?Homog=C3=A9n=C3=A9isation=20des=20erreurs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Storage.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index b938670..6d172cd 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -349,10 +349,10 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
 
         if range is None :
             try:
-                reponse = requests.get(storage_type.value + path, stream=True)
+                reponse = requests.get(f"{storage_type.value}{path}", stream=True)
                 data = reponse.content
                 if reponse.status_code == 404 :
-                    raise StorageError(storage_type.name, "Requested file does not exist")
+                    raise FileNotFoundError(f"{storage_type.value}{path}")
             except Exception as e:
                 raise StorageError(storage_type.name, e)
         else :
@@ -519,8 +519,8 @@ def exists(path: str) -> bool:
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
 
         try:
-            reponse = requests.get(storage_type.value + path, stream=True)
-            if reponse.status_code == 200 :
+            response = requests.get(storage_type.value + path, stream=True)
+            if response.status_code == 200 :
                 return True
             else :
                 return False
@@ -813,9 +813,9 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
     elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.FILE :
 
         try:
-            reponse = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream = True)
             with open(to_path, "wb") as f:
-                for chunk in reponse.iter_content(chunk_size=65536) :
+                for chunk in response.iter_content(chunk_size=65536) :
                     if chunk:
                         f.write(chunk)
 
@@ -827,9 +827,9 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
-            reponse = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream = True)
             offset = 0
-            for chunk in reponse.iter_content(chunk_size=65536) :
+            for chunk in response.iter_content(chunk_size=65536) :
                 if chunk:
                     size = len(chunk)
                     to_ioctx.write(to_base_name, chunk, offset)
@@ -843,10 +843,10 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            reponse = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream = True)
             with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
                 name_fich = f.name
-                for chunk in reponse.iter_content(chunk_size=65536) :
+                for chunk in response.iter_content(chunk_size=65536) :
                     if chunk:
                         f.write(chunk)
 

From 74fc1501c484323ac80ff73882d7e7fdebcf8926 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Tue, 18 Apr 2023 16:33:37 +0200
Subject: [PATCH 32/89] =?UTF-8?q?RasterSet.from=5Flist()=20impl=C3=A9ment?=
 =?UTF-8?q?=C3=A9e.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Raster.py   | 86 ++++++++++++++++++++++++++++++++++++++++++++
 tests/test_Raster.py | 84 +++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 167 insertions(+), 3 deletions(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 2a06ee6..26003ac 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -137,3 +137,89 @@ def from_parameters(cls, path: str, bands: int, bbox: Tuple[float, float, float,
         self.mask = mask
 
         return self
+
+
+
+class RasterSet:
+    """A structure describing a set of raster data
+
+    Attributes :
+        raster_list (List[Raster]): List of Raster instances in the set
+        colors (List[Dict]): List of color properties for each raster instance. Contains only one element if the set is homogenous.
+            Element properties:
+                bands (int): number of color bands (or channels)
+                format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
+        srs (str): Name of the set's spatial reference system 
+        bbox (Tuple[float, float, float, float]): bounding rectange in the data projection, enclosing the whole set
+    """
+
+    def __init__(self) -> None:
+        self.raster_list = []
+        self.colors = []
+        self.srs = None
+        self.bbox = (None, None, None, None)
+
+
+    @classmethod
+    def from_list(cls, path: str, srs: str) -> 'RasterSet':
+        """Creates a RasterSet object from an images list path and a srs name
+
+        Args:
+            path (str): path to the images list file or object (each line in this list contains the path to an image file or object in the set)
+
+        Examples:
+
+            Loading informations from a file stored list
+
+                from rok4.Raster import RasterSet
+
+                try:
+                    raster_set = RasterSet.from_list(path = "file:///data/images/SC1000_TIFF_LAMB93_FXX.list", srs = "EPSG:3857")
+
+                except Exception as e:
+                    print(f"Cannot load information from list file : {e}")
+
+        Raises:
+            RuntimeError: raised by OGR/GDAL if anything goes wrong
+            NotImplementedError: Storage type not handled
+
+        Returns:
+            RasterSet: a RasterSet instance
+        """
+
+        self = cls()
+
+        self.srs = srs
+
+        local_list_path = get_osgeo_path(path)
+        image_list = []
+        with open(file = local_list_path, mode = "r") as list_file:
+            for line in list_file:
+                image_path = line.strip(' \t\n\r') # unittest.mock.mock_open weirdly leaves newline character at each line end
+                image_list.append(image_path)
+
+        temp_bbox = [None, None, None, None]
+        for image_path in image_list:
+            raster = Raster.from_file(image_path)
+            self.raster_list.append(raster)
+            if temp_bbox == [None, None, None, None]:
+                for i in range(0, 4, 1):
+                    temp_bbox[i] = raster.bbox[i]
+            else:
+                if temp_bbox[0] > raster.bbox[0]:
+                    temp_bbox[0] = raster.bbox[0]
+                if temp_bbox[1] > raster.bbox[1]:
+                    temp_bbox[1] = raster.bbox[1]
+                if temp_bbox[2] < raster.bbox[2]:
+                    temp_bbox[2] = raster.bbox[2]
+                if temp_bbox[3] < raster.bbox[3]:
+                    temp_bbox[3] = raster.bbox[3]
+
+            color_dict = {'bands': raster.bands, 'format': raster.format}
+            if color_dict not in self.colors:
+                self.colors.append(color_dict)
+        
+        self.bbox = (temp_bbox[0], temp_bbox[1], temp_bbox[2], temp_bbox[3])
+
+        return self
+    
\ No newline at end of file
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index d7b2b24..4e2390c 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,16 +1,19 @@
 """Describes unit tests for the rok4.Raster module."""
 
-from rok4.Raster import Raster
+from rok4.Raster import Raster, RasterSet
 from rok4.Utils import ColorFormat
 
 import math
+import random
 
 import pytest
 from unittest import mock, TestCase
 from unittest.mock import *
 
 
-class TestFromFile(TestCase):
+# rok4.Raster.Raster class tests
+
+class TestRasterFromFile(TestCase):
     """Test class for the rok4.Raster.Raster.from_file(path) class constructor."""
 
     def setUp(self):
@@ -136,10 +139,12 @@ def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_i
         mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
 
 
-class TestFromParameters(TestCase):
+class TestRasterFromParameters(TestCase):
     """Test class for the rok4.Raster.Raster.from_parameters(**kwargs) class constructor."""
 
     def test_image(self):
+        """Test case: parameters describing an image without mask"""
+
         i_path = "file:///path/to/image.tif"
         i_bbox = (-5.4, 41.3, 9.8, 51.3)
         i_bands = 4
@@ -159,6 +164,8 @@ def test_image(self):
         assert result.mask is None
 
     def test_image_and_mask(self):
+        """Test case: parameters describing an image with mask"""
+
         i_path = "file:///path/to/image.tif"
         i_mask = "file:///path/to/image.msk"
         i_bbox = (-5.4, 41.3, 9.8, 51.3)
@@ -178,3 +185,74 @@ def test_image_and_mask(self):
         assert result.dimensions == i_dimensions
         assert result.mask == i_mask
     
+
+# rok4.Raster.RasterSet class tests
+
+class TestRasterSetFromList(TestCase):
+    """Test class for the rok4.Raster.RasterSet.from_list(path, srs) class constructor."""
+
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster.Raster.from_file')
+    def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
+        """Test case: list of 3 or more valid image files"""
+
+        file_number = random.randint(3, 100)
+        file_list = []
+        for n in range(0, file_number, 1):
+            file_list.append(f"s3://test_bucket/image_{n+1}.tif")
+        file_list_string = '\n'.join(file_list)
+        mocked_open = mock_open(read_data = file_list_string)
+
+        list_path = "s3://test_bucket/raster_set.list"
+        list_local_path = "/tmp/raster_set.list"
+        
+        mocked_get_osgeo_path.return_value = list_local_path
+
+        raster_list = []
+        expected_colors = []
+        for n in range(0, file_number, 1):
+            raster = MagicMock(Raster)
+            raster.path = file_list[n]
+            raster.bbox = (-0.75 + math.floor(n/3), -1.33 + n - 3 * math.floor(n/3), 0.25 + math.floor(n/3), -0.33 +  n - 3 * math.floor(n/3))
+            raster.format = random.choice([ColorFormat.BIT, ColorFormat.UINT8, ColorFormat.FLOAT32])
+            if raster.format == ColorFormat.BIT:
+                raster.bands = 1
+            else:
+                raster.bands = random.randint(1, 4)
+            
+            color_dict = {'bands': raster.bands, 'format': raster.format}
+            if color_dict not in expected_colors:
+                expected_colors.append(color_dict)
+
+            raster_list.append(raster)
+
+        mocked_from_file.side_effect = raster_list
+
+        srs = "EPSG:4326"
+        with mock.patch('rok4.Raster.open', mocked_open):
+            result = RasterSet.from_list(list_path, srs)
+
+        assert result.srs == srs
+        mocked_get_osgeo_path.assert_called_once_with(list_path)
+        mocked_open.assert_called_once_with(file=list_local_path, mode='r')
+        assert result.raster_list == raster_list
+        assert math.isclose(result.bbox[0], -0.75, rel_tol=1e-5)
+        assert math.isclose(result.bbox[1], -1.33, rel_tol=1e-5)
+        assert math.isclose(result.bbox[2], 0.25 + math.floor((file_number-1)/3), rel_tol=1e-5)
+        assert math.isclose(result.bbox[3], 1.67, rel_tol=1e-5)
+        assert result.colors == expected_colors
+
+
+
+
+
+        
+
+
+
+
+
+
+
+
+

From 87e20a1344f1ce848c8f21164e7dd90efbb2d5ec Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Mon, 24 Apr 2023 11:06:14 +0200
Subject: [PATCH 33/89] =?UTF-8?q?Propri=C3=A9t=C3=A9=20RasterSet.serializa?=
 =?UTF-8?q?ble=20impl=C3=A9ment=C3=A9e.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Raster.py   | 34 ++++++++++++++++++++++++-
 tests/test_Raster.py | 59 ++++++++++++++++++++++++++++++++++++--------
 2 files changed, 82 insertions(+), 11 deletions(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 26003ac..c35c6a1 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -10,7 +10,7 @@
 from enum import Enum
 
 from osgeo import ogr, gdal
-from typing import Tuple
+from typing import Tuple, Dict
 
 from rok4.Storage import exists, get_osgeo_path
 from rok4.Utils import ColorFormat, compute_bbox,compute_format
@@ -222,4 +222,36 @@ def from_list(cls, path: str, srs: str) -> 'RasterSet':
         self.bbox = (temp_bbox[0], temp_bbox[1], temp_bbox[2], temp_bbox[3])
 
         return self
+
+    @property
+    def serializable(self) -> Dict:
+        """Get the dict version of the raster set, descriptor compliant
+
+        Returns:
+            Dict: descriptor structured object description
+        """
+
+        serialization = {
+            'bbox': self.bbox,
+            'srs': self.srs,
+            'colors': self.colors,
+            'raster_list' : []
+        }
+
+        for raster in self.raster_list:
+            raster_dict = {
+                'path': raster.path,
+                'dimensions': raster.dimensions,
+                'bbox': raster.bbox,
+                'bands': raster.bands,
+                'format': raster.format
+            }
+            if raster.mask:
+                raster_dict['mask'] = raster.mask
+
+            serialization['raster_list'].append(raster_dict)
+
+        return serialization
+
+
     
\ No newline at end of file
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 4e2390c..2e4a5f3 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -209,26 +209,46 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
         mocked_get_osgeo_path.return_value = list_local_path
 
         raster_list = []
-        expected_colors = []
+        colors = []
+        serializable = {
+            'raster_list': []
+        }
         for n in range(0, file_number, 1):
             raster = MagicMock(Raster)
             raster.path = file_list[n]
             raster.bbox = (-0.75 + math.floor(n/3), -1.33 + n - 3 * math.floor(n/3), 0.25 + math.floor(n/3), -0.33 +  n - 3 * math.floor(n/3))
             raster.format = random.choice([ColorFormat.BIT, ColorFormat.UINT8, ColorFormat.FLOAT32])
+
             if raster.format == ColorFormat.BIT:
                 raster.bands = 1
             else:
                 raster.bands = random.randint(1, 4)
+
+            if random.randint(0, 1) == 1:
+                raster.mask = raster.path.replace('.tif', '.msk')
+            else:
+                raster.mask = None
             
             color_dict = {'bands': raster.bands, 'format': raster.format}
-            if color_dict not in expected_colors:
-                expected_colors.append(color_dict)
+            if color_dict not in colors:
+                colors.append(color_dict)
+            raster.dimensions = (5000, 5000)
 
             raster_list.append(raster)
+            raster_serializable = {'path': raster.path, 'bands': raster.bands, 'format': raster.format, 'bbox': raster.bbox, 'dimensions': raster.dimensions}
+            if raster.mask: 
+                raster_serializable['mask'] = raster.mask
+            serializable['raster_list'].append(raster_serializable)
 
         mocked_from_file.side_effect = raster_list
 
         srs = "EPSG:4326"
+        serializable['srs'] =  srs
+        serializable['colors'] =  colors
+        bbox = (-0.75, -1.33, 0.25 + math.floor((file_number-1)/3), 1.67)
+        serializable['bbox'] = bbox
+
+
         with mock.patch('rok4.Raster.open', mocked_open):
             result = RasterSet.from_list(list_path, srs)
 
@@ -236,23 +256,42 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
         mocked_get_osgeo_path.assert_called_once_with(list_path)
         mocked_open.assert_called_once_with(file=list_local_path, mode='r')
         assert result.raster_list == raster_list
-        assert math.isclose(result.bbox[0], -0.75, rel_tol=1e-5)
-        assert math.isclose(result.bbox[1], -1.33, rel_tol=1e-5)
-        assert math.isclose(result.bbox[2], 0.25 + math.floor((file_number-1)/3), rel_tol=1e-5)
-        assert math.isclose(result.bbox[3], 1.67, rel_tol=1e-5)
-        assert result.colors == expected_colors
-
+        for i in range(0, 4):
+            assert math.isclose(result.bbox[i], bbox[i], rel_tol=1e-5)
+        assert len(result.colors) > 0
+        assert result.colors == colors
 
+        result_serializable = result.serializable
+        for i in range(0, 4):
+            assert math.isclose(result_serializable['bbox'][i], serializable['bbox'][i], rel_tol=1e-5)
+        for key in serializable.keys():
+            if key != 'bbox':
+                assert result_serializable[key] == serializable[key]
 
 
+class TestRasterSetFromDescriptor(TestCase):
+    """Test class for the rok4.Raster.RasterSet.from_descriptor(path) class constructor."""
 
-        
 
+class TestRasterSetWriteDescriptor(TestCase):
+    """Test class for the rok4.Raster.RasterSet.write_descriptor(path) class method."""
 
+    def test_ok(self):
 
+        serializable = {
+            'srs' : 'EPSG:3957',
+            'bbox': (),
+            'colors': [],
+            'raster_list': []
+        }
 
 
+        assert False
+   
 
 
 
+class TestRasterSetWriteVRT(TestCase):
+    """Test class for the rok4.Raster.RasterSet.write_vrt(path) class constructor."""
 
+        

From f364a22bd4dbdb638b91010c0e3c798a6e28af58 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Mon, 24 Apr 2023 16:24:41 +0200
Subject: [PATCH 34/89] =?UTF-8?q?Constructeur=20'RasterSet.from=5Fdescript?=
 =?UTF-8?q?or(path)'=20impl=C3=A9ment=C3=A9.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Raster.py   | 69 +++++++++++++++++++++++++++++++++--
 tests/test_Raster.py | 86 +++++++++++++++++++++++++++++++++-----------
 2 files changed, 131 insertions(+), 24 deletions(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index c35c6a1..a79242c 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -6,11 +6,13 @@
 
 """
 
+import copy
+import json
 import re
 from enum import Enum
+from typing import Tuple, Dict
 
 from osgeo import ogr, gdal
-from typing import Tuple, Dict
 
 from rok4.Storage import exists, get_osgeo_path
 from rok4.Utils import ColorFormat, compute_bbox,compute_format
@@ -223,6 +225,60 @@ def from_list(cls, path: str, srs: str) -> 'RasterSet':
 
         return self
 
+
+    @classmethod
+    def from_descriptor(cls, path: str) -> 'RasterSet':
+        """Creates a RasterSet object from a descriptor file or object
+
+        Args:
+            path (str): path to the descriptor file or object
+
+        Examples:
+
+            Loading informations from a file stored descriptor
+
+                from rok4.Raster import RasterSet
+
+                try:
+                    raster_set = RasterSet.from_descriptor("file:///data/images/descriptor.json")
+
+                except Exception as e:
+                    print(f"Cannot load information from descriptor file : {e}")
+
+        Raises:
+            RuntimeError: raised by OGR/GDAL if anything goes wrong
+            NotImplementedError: Storage type not handled
+
+        Returns:
+            RasterSet: a RasterSet instance
+        """
+
+        self = cls()
+
+        descriptor_path = get_osgeo_path(path)
+        with open(file = descriptor_path, mode = 'r') as file_handle:
+            raw_content = file_handle.read()
+
+        serialization = json.loads(raw_content)
+
+        self.srs = serialization['srs']
+        self.raster_list = []
+        for raster_dict in serialization['raster_list']:
+            parameters = copy.deepcopy(raster_dict)
+            parameters['bbox'] = (raster_dict['bbox'][0], raster_dict['bbox'][1], raster_dict['bbox'][2], raster_dict['bbox'][3])
+            parameters['dimensions'] = (raster_dict['dimensions'][0], raster_dict['dimensions'][1])
+            parameters['format'] = ColorFormat[ raster_dict['format'] ]
+            self.raster_list.append(Raster.from_parameters(**parameters))
+        self.bbox = serialization['bbox']
+        self.colors = []
+        for color_dict in serialization['colors']:
+            color_item = copy.deepcopy(color_dict)
+            color_item['format'] = ColorFormat[ color_dict['format'] ]
+            self.colors.append(color_item)
+
+        return self
+
+
     @property
     def serializable(self) -> Dict:
         """Get the dict version of the raster set, descriptor compliant
@@ -234,17 +290,24 @@ def serializable(self) -> Dict:
         serialization = {
             'bbox': self.bbox,
             'srs': self.srs,
-            'colors': self.colors,
+            'colors': [],
             'raster_list' : []
         }
 
+        for color in self.colors:
+            color_serial = {
+                'bands': color['bands'],
+                'format': color['format'].name
+            }
+            serialization['colors'].append(color_serial)
+
         for raster in self.raster_list:
             raster_dict = {
                 'path': raster.path,
                 'dimensions': raster.dimensions,
                 'bbox': raster.bbox,
                 'bands': raster.bands,
-                'format': raster.format
+                'format': raster.format.name
             }
             if raster.mask:
                 raster_dict['mask'] = raster.mask
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 2e4a5f3..7d097ee 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -3,7 +3,9 @@
 from rok4.Raster import Raster, RasterSet
 from rok4.Utils import ColorFormat
 
+import copy
 import math
+import json
 import random
 
 import pytest
@@ -211,7 +213,8 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
         raster_list = []
         colors = []
         serializable = {
-            'raster_list': []
+            'raster_list': [],
+            'colors': []
         }
         for n in range(0, file_number, 1):
             raster = MagicMock(Raster)
@@ -232,10 +235,11 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
             color_dict = {'bands': raster.bands, 'format': raster.format}
             if color_dict not in colors:
                 colors.append(color_dict)
+                serializable['colors'].append({'bands': raster.bands, 'format': raster.format.name})
             raster.dimensions = (5000, 5000)
 
             raster_list.append(raster)
-            raster_serializable = {'path': raster.path, 'bands': raster.bands, 'format': raster.format, 'bbox': raster.bbox, 'dimensions': raster.dimensions}
+            raster_serializable = {'path': raster.path, 'bands': raster.bands, 'format': raster.format.name, 'bbox': raster.bbox, 'dimensions': raster.dimensions}
             if raster.mask: 
                 raster_serializable['mask'] = raster.mask
             serializable['raster_list'].append(raster_serializable)
@@ -243,27 +247,24 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
         mocked_from_file.side_effect = raster_list
 
         srs = "EPSG:4326"
-        serializable['srs'] =  srs
-        serializable['colors'] =  colors
+        serializable['srs'] = srs
         bbox = (-0.75, -1.33, 0.25 + math.floor((file_number-1)/3), 1.67)
         serializable['bbox'] = bbox
 
-
         with mock.patch('rok4.Raster.open', mocked_open):
             result = RasterSet.from_list(list_path, srs)
 
+        result_serializable = result.serializable
+
         assert result.srs == srs
         mocked_get_osgeo_path.assert_called_once_with(list_path)
         mocked_open.assert_called_once_with(file=list_local_path, mode='r')
         assert result.raster_list == raster_list
-        for i in range(0, 4):
+        for i in range(0, 4, 1):
             assert math.isclose(result.bbox[i], bbox[i], rel_tol=1e-5)
+            assert math.isclose(result_serializable['bbox'][i], serializable['bbox'][i], rel_tol=1e-5)
         assert len(result.colors) > 0
         assert result.colors == colors
-
-        result_serializable = result.serializable
-        for i in range(0, 4):
-            assert math.isclose(result_serializable['bbox'][i], serializable['bbox'][i], rel_tol=1e-5)
         for key in serializable.keys():
             if key != 'bbox':
                 assert result_serializable[key] == serializable[key]
@@ -272,22 +273,65 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
 class TestRasterSetFromDescriptor(TestCase):
     """Test class for the rok4.Raster.RasterSet.from_descriptor(path) class constructor."""
 
+    @mock.patch('rok4.Raster.get_osgeo_path')
+    @mock.patch('rok4.Raster.Raster.from_parameters')
+    def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
+        serialization = {
+            'bbox': (550000.000, 6210000.000, 570000.000, 6230000.000),
+            'colors': [{'bands': 3, 'format': 'UINT8'}],
+            'raster_list': [
+                {'bands': 3, 'bbox': (550000.000, 6210000.000, 560000.000, 6220000.000), 'dimensions': (5000,5000), 'format': 'UINT8', 'mask': 'file:///path/to/images/550000_6220000.msk', 'path': 'file:///path/to/images/550000_6220000.tif'},
+                {'bands': 3, 'bbox': (560000.000, 6210000.000, 570000.000, 6220000.000), 'dimensions': (5000,5000), 'format': 'UINT8', 'mask': 'file:///path/to/images/560000_6220000.msk', 'path': 'file:///path/to/images/560000_6220000.tif'},
+                {'bands': 3, 'bbox': (550000.000, 6220000.000, 560000.000, 6230000.000), 'dimensions': (5000,5000), 'format': 'UINT8', 'mask': 'file:///path/to/images/550000_6230000.msk', 'path': 'file:///path/to/images/550000_6230000.tif'}
+            ],
+            'srs': 'IGNF:LAMB93'
+        }
+        desc_path = 'file:///path/to/descriptor.json'
+        local_path = '/path/to/descriptor.json'
+        desc_content = json.dumps(serialization)
 
-class TestRasterSetWriteDescriptor(TestCase):
-    """Test class for the rok4.Raster.RasterSet.write_descriptor(path) class method."""
+        raster_list = []
+        raster_args_list = []
+        for raster_dict in serialization['raster_list']:
+            raster_properties = copy.deepcopy(raster_dict)
+            raster_properties['format'] = ColorFormat[ raster_dict['format'] ]
+            raster = MagicMock(Raster)
+            raster.configure_mock(**raster_properties)
+            raster_list.append(raster)
+            raster_args_list.append(raster_properties)
 
-    def test_ok(self):
+        mocked_from_parameters.side_effect = raster_list
+        mocked_get_osgeo_path.return_value = local_path
+        mocked_open = mock_open(read_data = desc_content)
+        with mock.patch('rok4.Raster.open', mocked_open):
+            result = RasterSet.from_descriptor(desc_path)
+
+        mocked_get_osgeo_path.assert_called_once_with(desc_path)
+        mocked_open.assert_called_once_with(file=local_path, mode='r')
+        assert result.srs == serialization['srs']
+        mocked_from_parameters.assert_called()
+        assert mocked_from_parameters.call_count == 3
+        for i in range(0, len(raster_args_list), 1):
+            assert mocked_from_parameters.call_args_list[i] == call(**raster_args_list[i])
+        assert result.raster_list == raster_list
+        for i in range(0, 4, 1):
+            assert math.isclose(result.bbox[i], serialization['bbox'][i], rel_tol=1e-5)
+        assert len(result.colors) > 0
+        for i in range(0, len(serialization['colors']), 1):
+            expected_color = copy.deepcopy(serialization['colors'][i])
+            expected_color['format'] = ColorFormat[ serialization['colors'][i]['format'] ]
+            assert result.colors[i] == expected_color
 
-        serializable = {
-            'srs' : 'EPSG:3957',
-            'bbox': (),
-            'colors': [],
-            'raster_list': []
-        }
+        result_serializable = result.serializable
+        for i in range(0, 4, 1):
+            assert math.isclose(result_serializable['bbox'][i], serialization['bbox'][i], rel_tol=1e-5)
+        for key in serialization.keys():
+            if key != 'bbox':
+                assert result_serializable[key] == serialization[key]
 
 
-        assert False
-   
+class TestRasterSetWriteDescriptor(TestCase):
+    """Test class for the rok4.Raster.RasterSet.write_descriptor(path) class method."""
 
 
 

From 78625b311b139f0491182d378103658babcc3abc Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Tue, 25 Apr 2023 12:03:31 +0200
Subject: [PATCH 35/89] =?UTF-8?q?Fonction=20RasterSet.write=5Fdescriptor()?=
 =?UTF-8?q?=20impl=C3=A9ment=C3=A9e.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Raster.py   | 29 +++++++++----
 tests/test_Raster.py | 96 ++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 110 insertions(+), 15 deletions(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index a79242c..22f3802 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -14,7 +14,7 @@
 
 from osgeo import ogr, gdal
 
-from rok4.Storage import exists, get_osgeo_path
+from rok4.Storage import exists, get_osgeo_path, put_data_str
 from rok4.Utils import ColorFormat, compute_bbox,compute_format
 
 # Enable GDAL/OGR exceptions
@@ -265,11 +265,11 @@ def from_descriptor(cls, path: str) -> 'RasterSet':
         self.raster_list = []
         for raster_dict in serialization['raster_list']:
             parameters = copy.deepcopy(raster_dict)
-            parameters['bbox'] = (raster_dict['bbox'][0], raster_dict['bbox'][1], raster_dict['bbox'][2], raster_dict['bbox'][3])
-            parameters['dimensions'] = (raster_dict['dimensions'][0], raster_dict['dimensions'][1])
+            parameters['bbox'] = tuple(raster_dict['bbox'])
+            parameters['dimensions'] = tuple(raster_dict['dimensions'])
             parameters['format'] = ColorFormat[ raster_dict['format'] ]
             self.raster_list.append(Raster.from_parameters(**parameters))
-        self.bbox = serialization['bbox']
+        self.bbox = tuple(serialization['bbox'])
         self.colors = []
         for color_dict in serialization['colors']:
             color_item = copy.deepcopy(color_dict)
@@ -288,7 +288,7 @@ def serializable(self) -> Dict:
         """
 
         serialization = {
-            'bbox': self.bbox,
+            'bbox': list(self.bbox),
             'srs': self.srs,
             'colors': [],
             'raster_list' : []
@@ -304,8 +304,8 @@ def serializable(self) -> Dict:
         for raster in self.raster_list:
             raster_dict = {
                 'path': raster.path,
-                'dimensions': raster.dimensions,
-                'bbox': raster.bbox,
+                'dimensions': list(raster.dimensions),
+                'bbox': list(raster.bbox),
                 'bands': raster.bands,
                 'format': raster.format.name
             }
@@ -317,4 +317,19 @@ def serializable(self) -> Dict:
         return serialization
 
 
+    def write_descriptor(self, path: str = None) -> None:
+        """Print raster set's descriptor as JSON
+
+        Args:
+            path (str, optional): Complete path (file or object) where to print the raster set's JSON. Defaults to None, JSON is printed to standard output.
+        """
+
+        content = json.dumps(self.serializable, sort_keys=True)
+        if path is None:
+            print(content)
+        else:
+            put_data_str(content, path)
+
+
+
     
\ No newline at end of file
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 7d097ee..2a4e629 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -239,7 +239,7 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
             raster.dimensions = (5000, 5000)
 
             raster_list.append(raster)
-            raster_serializable = {'path': raster.path, 'bands': raster.bands, 'format': raster.format.name, 'bbox': raster.bbox, 'dimensions': raster.dimensions}
+            raster_serializable = {'path': raster.path, 'bands': raster.bands, 'format': raster.format.name, 'bbox': list(raster.bbox), 'dimensions': list(raster.dimensions)}
             if raster.mask: 
                 raster_serializable['mask'] = raster.mask
             serializable['raster_list'].append(raster_serializable)
@@ -249,7 +249,7 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
         srs = "EPSG:4326"
         serializable['srs'] = srs
         bbox = (-0.75, -1.33, 0.25 + math.floor((file_number-1)/3), 1.67)
-        serializable['bbox'] = bbox
+        serializable['bbox'] = list(bbox)
 
         with mock.patch('rok4.Raster.open', mocked_open):
             result = RasterSet.from_list(list_path, srs)
@@ -260,6 +260,7 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
         mocked_get_osgeo_path.assert_called_once_with(list_path)
         mocked_open.assert_called_once_with(file=list_local_path, mode='r')
         assert result.raster_list == raster_list
+        assert isinstance(result_serializable['bbox'], list)
         for i in range(0, 4, 1):
             assert math.isclose(result.bbox[i], bbox[i], rel_tol=1e-5)
             assert math.isclose(result_serializable['bbox'][i], serializable['bbox'][i], rel_tol=1e-5)
@@ -268,6 +269,7 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
         for key in serializable.keys():
             if key != 'bbox':
                 assert result_serializable[key] == serializable[key]
+        assert isinstance(result_serializable['bbox'], list)
 
 
 class TestRasterSetFromDescriptor(TestCase):
@@ -277,12 +279,12 @@ class TestRasterSetFromDescriptor(TestCase):
     @mock.patch('rok4.Raster.Raster.from_parameters')
     def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
         serialization = {
-            'bbox': (550000.000, 6210000.000, 570000.000, 6230000.000),
+            'bbox': [550000.000, 6210000.000, 570000.000, 6230000.000],
             'colors': [{'bands': 3, 'format': 'UINT8'}],
             'raster_list': [
-                {'bands': 3, 'bbox': (550000.000, 6210000.000, 560000.000, 6220000.000), 'dimensions': (5000,5000), 'format': 'UINT8', 'mask': 'file:///path/to/images/550000_6220000.msk', 'path': 'file:///path/to/images/550000_6220000.tif'},
-                {'bands': 3, 'bbox': (560000.000, 6210000.000, 570000.000, 6220000.000), 'dimensions': (5000,5000), 'format': 'UINT8', 'mask': 'file:///path/to/images/560000_6220000.msk', 'path': 'file:///path/to/images/560000_6220000.tif'},
-                {'bands': 3, 'bbox': (550000.000, 6220000.000, 560000.000, 6230000.000), 'dimensions': (5000,5000), 'format': 'UINT8', 'mask': 'file:///path/to/images/550000_6230000.msk', 'path': 'file:///path/to/images/550000_6230000.tif'}
+                {'bands': 3, 'bbox': [550000.000, 6210000.000, 560000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 'file:///path/to/images/550000_6220000.msk', 'path': 'file:///path/to/images/550000_6220000.tif'},
+                {'bands': 3, 'bbox': [560000.000, 6210000.000, 570000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 'file:///path/to/images/560000_6220000.msk', 'path': 'file:///path/to/images/560000_6220000.tif'},
+                {'bands': 3, 'bbox': [550000.000, 6220000.000, 560000.000, 6230000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 'file:///path/to/images/550000_6230000.msk', 'path': 'file:///path/to/images/550000_6230000.tif'}
             ],
             'srs': 'IGNF:LAMB93'
         }
@@ -295,8 +297,10 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
         for raster_dict in serialization['raster_list']:
             raster_properties = copy.deepcopy(raster_dict)
             raster_properties['format'] = ColorFormat[ raster_dict['format'] ]
-            raster = MagicMock(Raster)
-            raster.configure_mock(**raster_properties)
+            raster_properties['bbox'] = tuple(raster_dict['bbox'])
+            raster_properties['dimensions'] = tuple(raster_dict['dimensions'])
+
+            raster = MagicMock(Raster, **raster_properties)
             raster_list.append(raster)
             raster_args_list.append(raster_properties)
 
@@ -314,6 +318,7 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
         for i in range(0, len(raster_args_list), 1):
             assert mocked_from_parameters.call_args_list[i] == call(**raster_args_list[i])
         assert result.raster_list == raster_list
+        assert isinstance(result.bbox, tuple)
         for i in range(0, 4, 1):
             assert math.isclose(result.bbox[i], serialization['bbox'][i], rel_tol=1e-5)
         assert len(result.colors) > 0
@@ -323,6 +328,7 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
             assert result.colors[i] == expected_color
 
         result_serializable = result.serializable
+        assert isinstance(result_serializable['bbox'], list)
         for i in range(0, 4, 1):
             assert math.isclose(result_serializable['bbox'][i], serialization['bbox'][i], rel_tol=1e-5)
         for key in serialization.keys():
@@ -333,6 +339,80 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
 class TestRasterSetWriteDescriptor(TestCase):
     """Test class for the rok4.Raster.RasterSet.write_descriptor(path) class method."""
 
+    @mock.patch('rok4.Raster.put_data_str')
+    def test_ok_with_output_path(self, mocked_put_data_str):
+        serialization = {
+            'bbox': [550000.000, 6210000.000, 570000.000, 6230000.000],
+            'colors': [{'bands': 3, 'format': 'UINT8'}],
+            'raster_list': [
+                {'bands': 3, 'bbox': [550000.000, 6210000.000, 560000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/550000_6220000.msk', 'path': 's3://rok4bucket/images/550000_6220000.tif'},
+                {'bands': 3, 'bbox': [560000.000, 6210000.000, 570000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/560000_6220000.msk', 'path': 's3://rok4bucket/images/560000_6220000.tif'},
+                {'bands': 3, 'bbox': [550000.000, 6220000.000, 560000.000, 6230000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/550000_6230000.msk', 'path': 's3://rok4bucket/images/550000_6230000.tif'}
+            ],
+            'srs': 'IGNF:LAMB93'
+        }
+        content = json.dumps(serialization, sort_keys=True)
+        path = 's3://rok4bucket/dst_descriptor.json'
+
+        try:
+            rasterset = RasterSet()
+            rasterset.bbox = tuple(serialization['bbox'])
+            rasterset.srs = serialization['srs']
+            rasterset.colors = []
+            for color_dict in serialization['colors']:
+                rasterset.colors.append({'bands': color_dict['bands'], 'format': ColorFormat[ color_dict['format'] ]})
+            rasterset.raster_list = []
+            for raster_dict in serialization['raster_list']:
+                raster_args = copy.deepcopy(raster_dict)
+                raster_args['format'] = ColorFormat[ raster_dict['format'] ]
+                raster_args['bbox'] = tuple(raster_dict['bbox'])
+                raster_args['dimensions'] = tuple(raster_dict['dimensions'])
+                rasterset.raster_list.append(MagicMock(Raster, **raster_args))
+
+            rasterset.write_descriptor(path)
+
+        except Exception as exc:
+            assert False, f"Writing RasterSet's descriptor raises an exception: {exc}"
+
+        mocked_put_data_str.assert_called_once_with(content, path)
+
+
+    @mock.patch('rok4.Raster.print')
+    def test_ok_no_output_path(self, mocked_print):
+        serialization = {
+            'bbox': [550000.000, 6210000.000, 570000.000, 6230000.000],
+            'colors': [{'bands': 3, 'format': 'UINT8'}],
+            'raster_list': [
+                {'bands': 3, 'bbox': [550000.000, 6210000.000, 560000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/550000_6220000.msk', 'path': 's3://rok4bucket/images/550000_6220000.tif'},
+                {'bands': 3, 'bbox': [560000.000, 6210000.000, 570000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/560000_6220000.msk', 'path': 's3://rok4bucket/images/560000_6220000.tif'},
+                {'bands': 3, 'bbox': [550000.000, 6220000.000, 560000.000, 6230000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/550000_6230000.msk', 'path': 's3://rok4bucket/images/550000_6230000.tif'}
+            ],
+            'srs': 'IGNF:LAMB93'
+        }
+        content = json.dumps(serialization, sort_keys=True)
+
+        try:
+            rasterset = RasterSet()
+            rasterset.bbox = tuple(serialization['bbox'])
+            rasterset.srs = serialization['srs']
+            rasterset.colors = []
+            for color_dict in serialization['colors']:
+                rasterset.colors.append({'bands': color_dict['bands'], 'format': ColorFormat[ color_dict['format'] ]})
+            rasterset.raster_list = []
+            for raster_dict in serialization['raster_list']:
+                raster_args = copy.deepcopy(raster_dict)
+                raster_args['format'] = ColorFormat[ raster_dict['format'] ]
+                raster_args['bbox'] = tuple(raster_dict['bbox'])
+                raster_args['dimensions'] = tuple(raster_dict['dimensions'])
+                rasterset.raster_list.append(MagicMock(Raster, **raster_args))
+
+            rasterset.write_descriptor()
+
+        except Exception as exc:
+            assert False, f"Writing RasterSet's descriptor raises an exception: {exc}"
+
+        mocked_print.assert_called_once_with(content)
+
 
 
 class TestRasterSetWriteVRT(TestCase):

From 40d14c4b25bf075601f1fb06d0a7fb689b247ff9 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Wed, 3 May 2023 15:57:50 +0200
Subject: [PATCH 36/89] =?UTF-8?q?WIP:=20Homog=C3=A9n=C3=A9isation=20et=20m?=
 =?UTF-8?q?ise=20en=20conformit=C3=A9=20du=20code=20li=C3=A9=20=C3=A0=20li?=
 =?UTF-8?q?b=5Fraster=20avec=20PEP-8.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Raster.py   | 201 ++++++++++++-----------
 src/rok4/Utils.py    |  54 +++---
 tests/test_Raster.py | 379 +++++++++++++++++++++++++++----------------
 3 files changed, 373 insertions(+), 261 deletions(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 22f3802..7fecad3 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -1,9 +1,9 @@
-"""Provide functions to read information on raster data from file path or object path
+"""Provide functions to read information on raster data
 
 The module contains the following class :
 
-    - 'Raster' - Structure describing raster data.
-
+    - Raster - Structure describing raster data.
+    - RasterSet - Structure describing a set of raster data.
 """
 
 import copy
@@ -25,12 +25,18 @@ class Raster:
     """A structure describing raster data
 
     Attributes :
-        path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
-        bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
+        path (str): path to the file/object (ex:
+          file:///path/to/image.tif or s3://bucket/path/to/image.tif)
+        bbox (Tuple[float, float, float, float]): bounding rectange
+          in the data projection
         bands (int): number of color bands (or channels)
-        format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
-        mask (str): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
-        dimensions (Tuple[int, int]): image width and height expressed in pixels
+        format (ColorFormat): numeric variable format for color values.
+          Bit depth, as bits per channel, can be derived from it.
+        mask (str): path to the associated mask file or object, if any,
+          or None (same path as the image, but with a ".msk" extension
+          and TIFF format. ex:
+          file:///path/to/image.msk or s3://bucket/path/to/image.msk)
+        dimensions (Tuple[int, int]): image width and height, in pixels
     """
 
     def __init__(self) -> None:
@@ -42,7 +48,7 @@ def __init__(self) -> None:
         self.path = None
 
     @classmethod
-    def from_file(cls, path: str) -> 'Raster':
+    def from_file(cls, path: str) -> "Raster":
         """Creates a Raster object from an image
 
         Args:
@@ -55,7 +61,9 @@ def from_file(cls, path: str) -> 'Raster':
                 from rok4.Raster import Raster
 
                 try:
-                    raster = Raster.from_file("file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.tif")
+                    raster = Raster.from_file(
+                        "file:///data/SC1000/0040_6150_L93.tif"
+                    )
 
                 except Exception as e:
                     print(f"Cannot load information from image : {e}")
@@ -67,7 +75,6 @@ def from_file(cls, path: str) -> 'Raster':
         Returns:
             Raster: a Raster instance
         """
-
         if not exists(path):
             raise Exception(f"No file or object found at path '{path}'.")
 
@@ -78,15 +85,16 @@ def from_file(cls, path: str) -> 'Raster':
         image_datasource = gdal.Open(work_image_path)
         self.path = path
 
-        path_pattern = re.compile('(/[^/]+?)[.][a-zA-Z0-9_-]+$')
-        mask_path = path_pattern.sub('\\1.msk', path)
+        path_pattern = re.compile("(/[^/]+?)[.][a-zA-Z0-9_-]+$")
+        mask_path = path_pattern.sub("\\1.msk", path)
 
         if exists(mask_path):            
             work_mask_path = get_osgeo_path(mask_path)
             mask_driver = gdal.IdentifyDriver(work_mask_path).ShortName
             if 'GTiff' != mask_driver:
-                raise Exception(f"Mask file '{mask_path}' is not a TIFF image. (GDAL driver : '{mask_driver}'")
-
+                message = (f"Mask file '{mask_path}' is not a TIFF image."
+                           + f" (GDAL driver : '{mask_driver}'")
+                raise Exception(message)
             self.mask = mask_path
         else:
             self.mask = None
@@ -99,28 +107,48 @@ def from_file(cls, path: str) -> 'Raster':
         return self
 
     @classmethod
-    def from_parameters(cls, path: str, bands: int, bbox: Tuple[float, float, float, float], dimensions: Tuple[int, int], format: ColorFormat, mask: str = None) -> 'Raster':
+    def from_parameters(
+            cls, path: str, bands: int, bbox: Tuple[float, float, float, float],
+            dimensions: Tuple[int, int], format: ColorFormat, mask: str = None) -> "Raster":
         """Creates a Raster object from parameters
 
         Args:
-            path (str): path to the file/object (ex: file:///path/to/image.tif or s3://bucket/path/to/image.tif)
+            path (str): path to the file/object (ex:
+              file:///path/to/image.tif or s3://bucket/image.tif)
             bands (int): number of color bands (or channels)
-            bbox (Tuple[float, float, float, float]): bounding rectange in the data projection
-            dimensions (Tuple[int, int]): image width and height expressed in pixels
-            format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
-            mask (str, optionnal): path to the associated mask file or object, if any, or None (same path as the image, but with a ".msk" extension and TIFF format. ex: file:///path/to/image.msk or s3://bucket/path/to/image.msk)
+            bbox (Tuple[float, float, float, float]): bounding rectange
+              in the data projection
+            dimensions (Tuple[int, int]): image width and height
+              expressed in pixels
+            format (ColorFormat): numeric format for color values.
+              Bit depth, as bits per channel, can be derived from it.
+            mask (str, optionnal): path to the associated mask, if any,
+              or None (same path as the image, but with a 
+              ".msk" extension and TIFF format. ex:
+              file:///path/to/image.msk or s3://bucket/image.msk)
 
         Examples:
 
-            Loading informations from parameters, related to a TIFF main image coupled to a TIFF mask image
+            Loading informations from parameters, related to 
+              a TIFF main image coupled to a TIFF mask image
 
                 from rok4.Raster import Raster
 
                 try:
-                    raster = Raster.from_parameters(path="file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.tif", mask="file:///data/images/SC1000_TIFF_LAMB93_FXX/SC1000_0040_6150_L93.msk", bands=3, format=ColorFormat.UINT8, dimensions=(2000, 2000), bbox=(40000.000, 5950000.000, 240000.000, 6150000.000))
+                    raster = Raster.from_parameters(
+                      path="file:///data/SC1000/_0040_6150_L93.tif",
+                      mask="file:///data/SC1000/0040_6150_L93.msk",
+                      bands=3,
+                      format=ColorFormat.UINT8,
+                      dimensions=(2000, 2000),
+                      bbox=(40000.000, 5950000.000,
+                            240000.000, 6150000.000)
+                    )
 
                 except Exception as e:
-                    print(f"Cannot load information from parameters : {e}")
+                    print(
+                      f"Cannot load information from parameters : {e}"
+                    )
 
         Raises:
             KeyError: a mandatory argument is missing
@@ -128,31 +156,32 @@ def from_parameters(cls, path: str, bands: int, bbox: Tuple[float, float, float,
         Returns:
             Raster: a Raster instance
         """
-
         self = cls()
-            
         self.path = path
         self.bands = bands
         self.bbox = bbox
         self.dimensions = dimensions
         self.format = format
         self.mask = mask
-
         return self
 
 
-
 class RasterSet:
     """A structure describing a set of raster data
 
     Attributes :
         raster_list (List[Raster]): List of Raster instances in the set
-        colors (List[Dict]): List of color properties for each raster instance. Contains only one element if the set is homogenous.
+        colors (List[Dict]): List of color properties for each raster
+              instance. Contains only one element if
+              the set is homogenous.
             Element properties:
                 bands (int): number of color bands (or channels)
-                format (ColorFormat): numeric variable format for color values. Bit depth, as bits per channel, can be derived from it.
+                format (ColorFormat): numeric variable format for
+                  color values. Bit depth, as bits per channel,
+                  can be derived from it.
         srs (str): Name of the set's spatial reference system 
-        bbox (Tuple[float, float, float, float]): bounding rectange in the data projection, enclosing the whole set
+        bbox (Tuple[float, float, float, float]): bounding rectange
+          in the data projection, enclosing the whole set
     """
 
     def __init__(self) -> None:
@@ -161,13 +190,14 @@ def __init__(self) -> None:
         self.srs = None
         self.bbox = (None, None, None, None)
 
-
     @classmethod
-    def from_list(cls, path: str, srs: str) -> 'RasterSet':
-        """Creates a RasterSet object from an images list path and a srs name
+    def from_list(cls, path: str, srs: str) -> "RasterSet":
+        """Instanciate a RasterSet from an images list path and a srs
 
         Args:
-            path (str): path to the images list file or object (each line in this list contains the path to an image file or object in the set)
+            path (str): path to the images list file or object
+              (each line in this list contains the path to
+              an image file or object in the set)
 
         Examples:
 
@@ -176,10 +206,15 @@ def from_list(cls, path: str, srs: str) -> 'RasterSet':
                 from rok4.Raster import RasterSet
 
                 try:
-                    raster_set = RasterSet.from_list(path = "file:///data/images/SC1000_TIFF_LAMB93_FXX.list", srs = "EPSG:3857")
+                    raster_set = RasterSet.from_list(
+                      path="file:///data/SC1000.list",
+                      srs="EPSG:3857"
+                    )
 
                 except Exception as e:
-                    print(f"Cannot load information from list file : {e}")
+                    print(
+                      f"Cannot load information from list file : {e}"
+                    )
 
         Raises:
             RuntimeError: raised by OGR/GDAL if anything goes wrong
@@ -188,16 +223,14 @@ def from_list(cls, path: str, srs: str) -> 'RasterSet':
         Returns:
             RasterSet: a RasterSet instance
         """
-
         self = cls()
-
         self.srs = srs
 
         local_list_path = get_osgeo_path(path)
         image_list = []
-        with open(file = local_list_path, mode = "r") as list_file:
+        with open(file=local_list_path, mode="r") as list_file:
             for line in list_file:
-                image_path = line.strip(' \t\n\r') # unittest.mock.mock_open weirdly leaves newline character at each line end
+                image_path = line.strip(" \t\n\r")
                 image_list.append(image_path)
 
         temp_bbox = [None, None, None, None]
@@ -216,18 +249,14 @@ def from_list(cls, path: str, srs: str) -> 'RasterSet':
                     temp_bbox[2] = raster.bbox[2]
                 if temp_bbox[3] < raster.bbox[3]:
                     temp_bbox[3] = raster.bbox[3]
-
-            color_dict = {'bands': raster.bands, 'format': raster.format}
+            color_dict = {"bands": raster.bands, "format": raster.format}
             if color_dict not in self.colors:
                 self.colors.append(color_dict)
-        
-        self.bbox = (temp_bbox[0], temp_bbox[1], temp_bbox[2], temp_bbox[3])
-
+        self.bbox = tuple(temp_bbox)
         return self
 
-
     @classmethod
-    def from_descriptor(cls, path: str) -> 'RasterSet':
+    def from_descriptor(cls, path: str) -> "RasterSet":
         """Creates a RasterSet object from a descriptor file or object
 
         Args:
@@ -240,10 +269,14 @@ def from_descriptor(cls, path: str) -> 'RasterSet':
                 from rok4.Raster import RasterSet
 
                 try:
-                    raster_set = RasterSet.from_descriptor("file:///data/images/descriptor.json")
+                    raster_set = RasterSet.from_descriptor(
+                      "file:///data/images/descriptor.json"
+                    )
 
                 except Exception as e:
-                    print(f"Cannot load information from descriptor file : {e}")
+                    message = ("Cannot load information from "
+                              + f"descriptor file : {e}")
+                    print(message)
 
         Raises:
             RuntimeError: raised by OGR/GDAL if anything goes wrong
@@ -252,33 +285,27 @@ def from_descriptor(cls, path: str) -> 'RasterSet':
         Returns:
             RasterSet: a RasterSet instance
         """
-
         self = cls()
-
         descriptor_path = get_osgeo_path(path)
-        with open(file = descriptor_path, mode = 'r') as file_handle:
+        with open(file=descriptor_path, mode="r") as file_handle:
             raw_content = file_handle.read()
-
         serialization = json.loads(raw_content)
-
-        self.srs = serialization['srs']
+        self.srs = serialization["srs"]
         self.raster_list = []
-        for raster_dict in serialization['raster_list']:
+        for raster_dict in serialization["raster_list"]:
             parameters = copy.deepcopy(raster_dict)
-            parameters['bbox'] = tuple(raster_dict['bbox'])
-            parameters['dimensions'] = tuple(raster_dict['dimensions'])
-            parameters['format'] = ColorFormat[ raster_dict['format'] ]
+            parameters["bbox"] = tuple(raster_dict["bbox"])
+            parameters["dimensions"] = tuple(raster_dict["dimensions"])
+            parameters["format"] = ColorFormat[ raster_dict["format"] ]
             self.raster_list.append(Raster.from_parameters(**parameters))
-        self.bbox = tuple(serialization['bbox'])
+        self.bbox = tuple(serialization["bbox"])
         self.colors = []
-        for color_dict in serialization['colors']:
+        for color_dict in serialization["colors"]:
             color_item = copy.deepcopy(color_dict)
-            color_item['format'] = ColorFormat[ color_dict['format'] ]
+            color_item["format"] = ColorFormat[ color_dict["format"] ]
             self.colors.append(color_item)
-
         return self
 
-
     @property
     def serializable(self) -> Dict:
         """Get the dict version of the raster set, descriptor compliant
@@ -286,50 +313,42 @@ def serializable(self) -> Dict:
         Returns:
             Dict: descriptor structured object description
         """
-
         serialization = {
-            'bbox': list(self.bbox),
-            'srs': self.srs,
-            'colors': [],
-            'raster_list' : []
+            "bbox": list(self.bbox),
+            "srs": self.srs,
+            "colors": [],
+            "raster_list" : []
         }
-
         for color in self.colors:
             color_serial = {
-                'bands': color['bands'],
-                'format': color['format'].name
+                "bands": color["bands"],
+                "format": color["format"].name
             }
-            serialization['colors'].append(color_serial)
-
+            serialization["colors"].append(color_serial)
         for raster in self.raster_list:
             raster_dict = {
-                'path': raster.path,
-                'dimensions': list(raster.dimensions),
-                'bbox': list(raster.bbox),
-                'bands': raster.bands,
-                'format': raster.format.name
+                "path": raster.path,
+                "dimensions": list(raster.dimensions),
+                "bbox": list(raster.bbox),
+                "bands": raster.bands,
+                "format": raster.format.name
             }
-            if raster.mask:
-                raster_dict['mask'] = raster.mask
-
-            serialization['raster_list'].append(raster_dict)
-
+            if raster.mask is not None:
+                raster_dict["mask"] = raster.mask
+            serialization["raster_list"].append(raster_dict)
         return serialization
 
-
     def write_descriptor(self, path: str = None) -> None:
         """Print raster set's descriptor as JSON
 
         Args:
-            path (str, optional): Complete path (file or object) where to print the raster set's JSON. Defaults to None, JSON is printed to standard output.
+            path (str, optional): Complete path (file or object)
+              where to print the raster set's JSON. Defaults to None,
+              JSON is printed to standard output.
         """
-
         content = json.dumps(self.serializable, sort_keys=True)
         if path is None:
             print(content)
         else:
             put_data_str(content, path)
 
-
-
-    
\ No newline at end of file
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 47e1bcd..6f8c7a7 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -171,11 +171,12 @@ def reproject_point(point: Tuple[float, float], sr_src: 'osgeo.osr.SpatialRefere
     return (x_dst, y_dst)
 
 
-def compute_bbox(source_dataset: gdal.Dataset) -> tuple:
+def compute_bbox(source_dataset: gdal.Dataset) -> Tuple:
     """Image boundingbox computing method
 
     Args:
-        source_dataset (gdal.Dataset): Dataset object created from the raster image
+        source_dataset (gdal.Dataset): Dataset instanciated
+          from the raster image
     
     Limitations:
         Image's axis must be parallel to SRS' axis
@@ -184,29 +185,27 @@ def compute_bbox(source_dataset: gdal.Dataset) -> tuple:
         AttributeError: source_dataset is not a gdal.Dataset instance.
         Exception: The dataset does not contain transform data.
     """
-
     bbox = None
     transform_vector = source_dataset.GetGeoTransform()
-
     if transform_vector is None:
-        raise Exception(f"No transform vector found in the dataset created from the following file : {source_dataset.GetFileList()[0]}")
-
+        raise Exception(
+            f"No transform vector found in the dataset created from "
+            + f"the following file : {source_dataset.GetFileList()[0]}"
+        )
     width = source_dataset.RasterXSize
     height = source_dataset.RasterYSize
-
     x_range = (
         transform_vector[0],
         transform_vector[0] + width * transform_vector[1] + height * transform_vector[2]
     )
-
     y_range = (
         transform_vector[3],
         transform_vector[3] + width * transform_vector[4] + height * transform_vector[5]
     )
-
     spatial_ref = source_dataset.GetSpatialRef()
     if spatial_ref is not None and spatial_ref.GetDataAxisToSRSAxisMapping() == [2, 1]:
-        # Coordonnées terrain de type (latitude, longitude) => on permute les coordonnées terrain par rapport à l'image
+        # Coordonnées terrain de type (latitude, longitude)
+        # => on permute les coordonnées terrain par rapport à l'image
         bbox = (
             min(y_range),
             min(x_range),
@@ -214,37 +213,33 @@ def compute_bbox(source_dataset: gdal.Dataset) -> tuple:
             max(x_range)
         )
     elif spatial_ref is None or spatial_ref.GetDataAxisToSRSAxisMapping() == [1, 2]:
-        # Coordonnées terrain de type (longitude, latitude) ou pas de SRS => les coordonnées terrain sont dans le même ordre que celle de l'image
+        # Coordonnées terrain de type (longitude, latitude) ou pas de SRS
+        # => les coordonnées terrain sont dans le même ordre que celle de l'image
         bbox = (
             min(x_range),
             min(y_range),
             max(x_range),
             max(y_range)
         )
-
     return bbox
 
 
-def compute_format(dataset: gdal.Dataset, path: str = None) -> 'ColorFormat':
+def compute_format(dataset: gdal.Dataset, path: str = None) -> ColorFormat:
     """Image color format computing method
 
     Args:
-        dataset (gdal.Dataset): Dataset object created from the raster image
+        dataset (gdal.Dataset): Dataset instanciated from the image
         path (str, optionnal): path to the original file/object
 
     Raises:
         AttributeError: source_dataset is not a gdal.Dataset instance.
-        Exception: Image has no color band or its color format is unsupported.
+        Exception: No color band found or unsupported color format.
     """
-
-    format = None
-
+    color_format = None
     if path is None:
         path = dataset.GetFileList()[0]
-
     if dataset.RasterCount < 1:
         raise Exception(f"Image {path} contains no color band.")
-    
     band_1_datatype = dataset.GetRasterBand(1).DataType
     data_type_name = gdal.GetDataTypeName(band_1_datatype)
     data_type_size = gdal.GetDataTypeSize(band_1_datatype)
@@ -252,16 +247,17 @@ def compute_format(dataset: gdal.Dataset, path: str = None) -> 'ColorFormat':
     color_name = None
     if color_interpretation is not None:
         color_name = gdal.GetColorInterpretationName(color_interpretation)
-    compression_regex_match = re.search(r'COMPRESSION\s*=\s*PACKBITS', gdal.Info(dataset))
-
+    compression_regex_match = re.search(r"COMPRESSION\s*=\s*PACKBITS", gdal.Info(dataset))
 
-    if data_type_name == "Byte" and data_type_size == 8 and color_name == "Palette" and compression_regex_match:
-        format = ColorFormat.BIT
+    if (data_type_name == "Byte" and data_type_size == 8
+        and color_name == "Palette" and compression_regex_match):
+        # Compris par libTIFF comme du noir et blanc sur 1 bit
+        color_format = ColorFormat.BIT
     elif data_type_name == "Byte" and data_type_size == 8:
-        format = ColorFormat.UINT8
+        color_format = ColorFormat.UINT8
     elif data_type_name == "Float32" and data_type_size == 32:
-        format = ColorFormat.FLOAT32
+        color_format = ColorFormat.FLOAT32
     else:
-        raise Exception(f"Unsupported color format for image {path} : '{data_type_name}' ({data_type_size} bits)")
-
-    return format
+        raise Exception(f"Unsupported color format for image {path} : "
+                        + f"'{data_type_name}' ({data_type_size} bits)")
+    return color_format
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 2a4e629..0cd92b7 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -16,7 +16,7 @@
 # rok4.Raster.Raster class tests
 
 class TestRasterFromFile(TestCase):
-    """Test class for the rok4.Raster.Raster.from_file(path) class constructor."""
+    """rok4.Raster.Raster.from_file(path) class constructor."""
 
     def setUp(self):
         self.source_image_path = "file:///home/user/image.tif"
@@ -28,35 +28,43 @@ def setUp(self):
         return super().setUp()
 
     def test_empty(self):
-        """Test case : Constructor called without the expected path argument."""
+        """Constructor called without the expected path argument."""
 
         with pytest.raises(TypeError):
             Raster.from_file()
 
-    @mock.patch('rok4.Raster.exists', return_value=False)
+    @mock.patch("rok4.Raster.exists", return_value=False)
     def test_image_not_found(self, mocked_exists):
-        """Test case : Constructor called on a path matching no file or object."""
+        """Constructor called on a path matching no file or object."""
 
         with pytest.raises(Exception):
             Raster.from_file(self.source_image_path)
 
         mocked_exists.assert_called_once_with(self.source_image_path)
 
-    @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster.compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster.compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_compute_format, mocked_get_osgeo_path):
-        """Test case : Constructor called nominally on an image without mask."""
+    @mock.patch("rok4.Raster.get_osgeo_path")
+    @mock.patch("rok4.Raster.compute_format", return_value=ColorFormat.UINT8)
+    @mock.patch("rok4.Raster.gdal.Open")
+    @mock.patch("rok4.Raster.compute_bbox")
+    @mock.patch("rok4.Raster.exists", side_effect=[True, False])
+    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open,
+                   mocked_compute_format, mocked_get_osgeo_path):
+        """Constructor called nominally on an image without mask."""
 
         mocked_compute_bbox.return_value = self.bbox
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3, 'RasterXSize': self.image_size[0], 'RasterYSize': self.image_size[1]})
+        mocked_gdal_open.return_value = type(
+            "", (object,), 
+            {
+                "RasterCount": 3,
+                "RasterXSize": self.image_size[0],
+                "RasterYSize": self.image_size[1]
+            }
+        )
         mocked_get_osgeo_path.return_value = self.osgeo_image_path
 
-        raster_object = Raster.from_file( self.source_image_path )
+        raster_object = Raster.from_file(self.source_image_path)
 
-        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
         mocked_get_osgeo_path.assert_called_once_with(self.source_image_path)
         mocked_gdal_open.assert_called_once_with( self.osgeo_image_path )
         assert raster_object.path == self.source_image_path
@@ -72,25 +80,35 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocke
         assert raster_object.format == ColorFormat.UINT8
         assert raster_object.dimensions == self.image_size
 
-    @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster.compute_format', return_value=ColorFormat.UINT8)
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.gdal.Open')
-    @mock.patch('rok4.Raster.compute_bbox')
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open, mocked_identifydriver, mocked_compute_format, mocked_get_osgeo_path):
-        """Test case : Constructor called nominally on an image with mask."""
+    @mock.patch("rok4.Raster.get_osgeo_path")
+    @mock.patch("rok4.Raster.compute_format", return_value=ColorFormat.UINT8)
+    @mock.patch("rok4.Raster.gdal.IdentifyDriver")
+    @mock.patch("rok4.Raster.gdal.Open")
+    @mock.patch("rok4.Raster.compute_bbox")
+    @mock.patch("rok4.Raster.exists", side_effect=[True, True])
+    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open,
+                            mocked_identifydriver, mocked_compute_format, mocked_get_osgeo_path):
+        """Constructor called nominally on an image with mask."""
 
         mocked_compute_bbox.return_value = self.bbox
-        mocked_gdal_open.return_value = type('', (object,), {'RasterCount': 3, 'RasterXSize': self.image_size[0], 'RasterYSize': self.image_size[1]})
+        mocked_gdal_open.return_value = type(
+            "",
+            (object,),
+            {
+                "RasterCount": 3,
+                "RasterXSize": self.image_size[0],
+                "RasterYSize": self.image_size[1]
+            }
+        )
         mocked_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
         # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'GTiff'})
+        mocked_identifydriver.return_value = type("", (object,), {"ShortName": "GTiff"})
 
         raster_object = Raster.from_file(self.source_image_path)
 
-        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
-        mocked_get_osgeo_path.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
+        mocked_get_osgeo_path.assert_has_calls([call(self.source_image_path),
+                                                call(self.source_mask_path)])
         mocked_identifydriver.assert_called_once_with(self.osgeo_mask_path)
         mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
         assert raster_object.path == self.source_image_path
@@ -106,11 +124,12 @@ def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_op
         assert raster_object.format == ColorFormat.UINT8
         assert raster_object.dimensions == self.image_size
 
-    @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=RuntimeError)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, False])
-    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_get_osgeo_path):
-        """Test case : Constructor called on an unsupported 'image' file or object."""
+    @mock.patch("rok4.Raster.get_osgeo_path")
+    @mock.patch("rok4.Raster.gdal.Open", side_effect=RuntimeError)
+    @mock.patch("rok4.Raster.exists", side_effect=[True, False])
+    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, 
+                                      mocked_get_osgeo_path):
+        """Test case : Constructor called on an unsupported image file or object."""
 
         mocked_get_osgeo_path.return_value = self.osgeo_image_path
 
@@ -121,31 +140,33 @@ def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, mocked_
         mocked_get_osgeo_path.assert_called_once_with(self.source_image_path)
         mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
 
-    @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster.gdal.IdentifyDriver')
-    @mock.patch('rok4.Raster.gdal.Open', side_effect=None)
-    @mock.patch('rok4.Raster.exists', side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_identifydriver, mocked_get_osgeo_path):
+    @mock.patch("rok4.Raster.get_osgeo_path")
+    @mock.patch("rok4.Raster.gdal.IdentifyDriver")
+    @mock.patch("rok4.Raster.gdal.Open", side_effect=None)
+    @mock.patch("rok4.Raster.exists", side_effect=[True, True])
+    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_identifydriver,
+                                     mocked_get_osgeo_path):
         """Test case : Constructor called on an unsupported mask file or object."""
 
         mocked_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
         # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
+        mocked_identifydriver.return_value = type("", (object,), {"ShortName": "JPG"})
 
         with pytest.raises(Exception):
             Raster.from_file(self.source_image_path)      
 
-        mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
-        mocked_get_osgeo_path.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
+        mocked_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
+        mocked_get_osgeo_path.assert_has_calls([call(self.source_image_path),
+                                                call(self.source_mask_path)])
         mocked_identifydriver.assert_called_once_with(self.osgeo_mask_path)
         mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
 
 
 class TestRasterFromParameters(TestCase):
-    """Test class for the rok4.Raster.Raster.from_parameters(**kwargs) class constructor."""
+    """rok4.Raster.Raster.from_parameters(**kwargs) class constructor."""
 
     def test_image(self):
-        """Test case: parameters describing an image without mask"""
+        """Parameters describing an image without mask"""
 
         i_path = "file:///path/to/image.tif"
         i_bbox = (-5.4, 41.3, 9.8, 51.3)
@@ -153,7 +174,8 @@ def test_image(self):
         i_format = ColorFormat.UINT8
         i_dimensions = (1920, 1080)
 
-        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions)
+        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format,
+                                        dimensions=i_dimensions)
 
         assert result.path == i_path
         assert math.isclose(result.bbox[0], i_bbox[0], rel_tol=1e-5)
@@ -166,7 +188,7 @@ def test_image(self):
         assert result.mask is None
 
     def test_image_and_mask(self):
-        """Test case: parameters describing an image with mask"""
+        """Parameters describing an image with mask"""
 
         i_path = "file:///path/to/image.tif"
         i_mask = "file:///path/to/image.msk"
@@ -175,7 +197,8 @@ def test_image_and_mask(self):
         i_format = ColorFormat.UINT8
         i_dimensions = (1920, 1080)
 
-        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format, dimensions=i_dimensions, mask=i_mask)
+        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format,
+                                        dimensions=i_dimensions, mask=i_mask)
 
         assert result.path == i_path
         assert math.isclose(result.bbox[0], i_bbox[0], rel_tol=1e-5)
@@ -191,18 +214,18 @@ def test_image_and_mask(self):
 # rok4.Raster.RasterSet class tests
 
 class TestRasterSetFromList(TestCase):
-    """Test class for the rok4.Raster.RasterSet.from_list(path, srs) class constructor."""
+    """rok4.Raster.RasterSet.from_list(path, srs) class constructor."""
 
-    @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster.Raster.from_file')
+    @mock.patch("rok4.Raster.get_osgeo_path")
+    @mock.patch("rok4.Raster.Raster.from_file")
     def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
-        """Test case: list of 3 or more valid image files"""
+        """List of 3 or more valid image files"""
 
         file_number = random.randint(3, 100)
         file_list = []
         for n in range(0, file_number, 1):
             file_list.append(f"s3://test_bucket/image_{n+1}.tif")
-        file_list_string = '\n'.join(file_list)
+        file_list_string = "\n".join(file_list)
         mocked_open = mock_open(read_data = file_list_string)
 
         list_path = "s3://test_bucket/raster_set.list"
@@ -213,14 +236,20 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
         raster_list = []
         colors = []
         serializable = {
-            'raster_list': [],
-            'colors': []
+            "raster_list": [],
+            "colors": []
         }
         for n in range(0, file_number, 1):
             raster = MagicMock(Raster)
             raster.path = file_list[n]
-            raster.bbox = (-0.75 + math.floor(n/3), -1.33 + n - 3 * math.floor(n/3), 0.25 + math.floor(n/3), -0.33 +  n - 3 * math.floor(n/3))
-            raster.format = random.choice([ColorFormat.BIT, ColorFormat.UINT8, ColorFormat.FLOAT32])
+            raster.bbox = (
+                -0.75 + math.floor(n/3),
+                -1.33 + n - 3 * math.floor(n/3),
+                0.25 + math.floor(n/3),
+                -0.33 +  n - 3 * math.floor(n/3)
+            )
+            raster.format = random.choice([ColorFormat.BIT, ColorFormat.UINT8,
+                                          ColorFormat.FLOAT32])
 
             if raster.format == ColorFormat.BIT:
                 raster.bands = 1
@@ -228,77 +257,107 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
                 raster.bands = random.randint(1, 4)
 
             if random.randint(0, 1) == 1:
-                raster.mask = raster.path.replace('.tif', '.msk')
+                raster.mask = raster.path.replace(".tif", ".msk")
             else:
                 raster.mask = None
             
-            color_dict = {'bands': raster.bands, 'format': raster.format}
+            color_dict = {"bands": raster.bands, "format": raster.format}
             if color_dict not in colors:
                 colors.append(color_dict)
-                serializable['colors'].append({'bands': raster.bands, 'format': raster.format.name})
+                serializable["colors"].append({"bands": raster.bands, 
+                                               "format": raster.format.name})
             raster.dimensions = (5000, 5000)
 
             raster_list.append(raster)
-            raster_serializable = {'path': raster.path, 'bands': raster.bands, 'format': raster.format.name, 'bbox': list(raster.bbox), 'dimensions': list(raster.dimensions)}
+            raster_serializable = {"path": raster.path, "bands": raster.bands,
+                                   "format": raster.format.name, "bbox": list(raster.bbox),
+                                   "dimensions": list(raster.dimensions)}
             if raster.mask: 
-                raster_serializable['mask'] = raster.mask
-            serializable['raster_list'].append(raster_serializable)
+                raster_serializable["mask"] = raster.mask
+            serializable["raster_list"].append(raster_serializable)
 
         mocked_from_file.side_effect = raster_list
 
         srs = "EPSG:4326"
-        serializable['srs'] = srs
-        bbox = (-0.75, -1.33, 0.25 + math.floor((file_number-1)/3), 1.67)
-        serializable['bbox'] = list(bbox)
-
-        with mock.patch('rok4.Raster.open', mocked_open):
+        serializable["srs"] = srs
+        bbox = (
+            -0.75,
+            -1.33,
+            0.25 + math.floor((file_number-1)/3),
+            1.67
+        )
+        serializable["bbox"] = list(bbox)
+
+        with mock.patch("rok4.Raster.open", mocked_open):
             result = RasterSet.from_list(list_path, srs)
 
         result_serializable = result.serializable
 
         assert result.srs == srs
         mocked_get_osgeo_path.assert_called_once_with(list_path)
-        mocked_open.assert_called_once_with(file=list_local_path, mode='r')
+        mocked_open.assert_called_once_with(file=list_local_path, mode="r")
         assert result.raster_list == raster_list
-        assert isinstance(result_serializable['bbox'], list)
+        assert isinstance(result_serializable["bbox"], list)
         for i in range(0, 4, 1):
             assert math.isclose(result.bbox[i], bbox[i], rel_tol=1e-5)
-            assert math.isclose(result_serializable['bbox'][i], serializable['bbox'][i], rel_tol=1e-5)
+            assert math.isclose(result_serializable["bbox"][i], serializable["bbox"][i],
+                                rel_tol=1e-5)
         assert len(result.colors) > 0
         assert result.colors == colors
         for key in serializable.keys():
-            if key != 'bbox':
+            if key != "bbox":
                 assert result_serializable[key] == serializable[key]
-        assert isinstance(result_serializable['bbox'], list)
+        assert isinstance(result_serializable["bbox"], list)
 
 
 class TestRasterSetFromDescriptor(TestCase):
-    """Test class for the rok4.Raster.RasterSet.from_descriptor(path) class constructor."""
+    """rok4.Raster.RasterSet.from_descriptor(path) class constructor."""
 
-    @mock.patch('rok4.Raster.get_osgeo_path')
-    @mock.patch('rok4.Raster.Raster.from_parameters')
+    @mock.patch("rok4.Raster.get_osgeo_path")
+    @mock.patch("rok4.Raster.Raster.from_parameters")
     def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
         serialization = {
-            'bbox': [550000.000, 6210000.000, 570000.000, 6230000.000],
-            'colors': [{'bands': 3, 'format': 'UINT8'}],
-            'raster_list': [
-                {'bands': 3, 'bbox': [550000.000, 6210000.000, 560000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 'file:///path/to/images/550000_6220000.msk', 'path': 'file:///path/to/images/550000_6220000.tif'},
-                {'bands': 3, 'bbox': [560000.000, 6210000.000, 570000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 'file:///path/to/images/560000_6220000.msk', 'path': 'file:///path/to/images/560000_6220000.tif'},
-                {'bands': 3, 'bbox': [550000.000, 6220000.000, 560000.000, 6230000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 'file:///path/to/images/550000_6230000.msk', 'path': 'file:///path/to/images/550000_6230000.tif'}
+            "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
+            "colors": [{"bands": 3, "format": "UINT8"}],
+            "raster_list": [
+                {
+                    "bands": 3,
+                    "bbox": [550000.000, 6210000.000, 560000.000, 6220000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "file:///path/to/images/550000_6220000.msk",
+                    "path": "file:///path/to/images/550000_6220000.tif"
+                },
+                {
+                    "bands": 3,
+                    "bbox": [560000.000, 6210000.000, 570000.000, 6220000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "file:///path/to/images/560000_6220000.msk",
+                    "path": "file:///path/to/images/560000_6220000.tif"
+                },
+                {
+                    "bands": 3,
+                    "bbox": [550000.000, 6220000.000, 560000.000, 6230000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "file:///path/to/images/550000_6230000.msk",
+                    "path": "file:///path/to/images/550000_6230000.tif"
+                }
             ],
-            'srs': 'IGNF:LAMB93'
+            "srs": "IGNF:LAMB93"
         }
-        desc_path = 'file:///path/to/descriptor.json'
-        local_path = '/path/to/descriptor.json'
+        desc_path = "file:///path/to/descriptor.json"
+        local_path = "/path/to/descriptor.json"
         desc_content = json.dumps(serialization)
 
         raster_list = []
         raster_args_list = []
-        for raster_dict in serialization['raster_list']:
+        for raster_dict in serialization["raster_list"]:
             raster_properties = copy.deepcopy(raster_dict)
-            raster_properties['format'] = ColorFormat[ raster_dict['format'] ]
-            raster_properties['bbox'] = tuple(raster_dict['bbox'])
-            raster_properties['dimensions'] = tuple(raster_dict['dimensions'])
+            raster_properties["format"] = ColorFormat[raster_dict["format"]]
+            raster_properties["bbox"] = tuple(raster_dict["bbox"])
+            raster_properties["dimensions"] = tuple(raster_dict["dimensions"])
 
             raster = MagicMock(Raster, **raster_properties)
             raster_list.append(raster)
@@ -307,12 +366,12 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
         mocked_from_parameters.side_effect = raster_list
         mocked_get_osgeo_path.return_value = local_path
         mocked_open = mock_open(read_data = desc_content)
-        with mock.patch('rok4.Raster.open', mocked_open):
+        with mock.patch("rok4.Raster.open", mocked_open):
             result = RasterSet.from_descriptor(desc_path)
 
         mocked_get_osgeo_path.assert_called_once_with(desc_path)
-        mocked_open.assert_called_once_with(file=local_path, mode='r')
-        assert result.srs == serialization['srs']
+        mocked_open.assert_called_once_with(file=local_path, mode="r")
+        assert result.srs == serialization["srs"]
         mocked_from_parameters.assert_called()
         assert mocked_from_parameters.call_count == 3
         for i in range(0, len(raster_args_list), 1):
@@ -320,53 +379,76 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
         assert result.raster_list == raster_list
         assert isinstance(result.bbox, tuple)
         for i in range(0, 4, 1):
-            assert math.isclose(result.bbox[i], serialization['bbox'][i], rel_tol=1e-5)
+            assert math.isclose(result.bbox[i], serialization["bbox"][i], rel_tol=1e-5)
         assert len(result.colors) > 0
-        for i in range(0, len(serialization['colors']), 1):
-            expected_color = copy.deepcopy(serialization['colors'][i])
-            expected_color['format'] = ColorFormat[ serialization['colors'][i]['format'] ]
+        for i in range(0, len(serialization["colors"]), 1):
+            expected_color = copy.deepcopy(serialization["colors"][i])
+            expected_color["format"] = ColorFormat[serialization["colors"][i]["format"]]
             assert result.colors[i] == expected_color
 
         result_serializable = result.serializable
-        assert isinstance(result_serializable['bbox'], list)
+        assert isinstance(result_serializable["bbox"], list)
         for i in range(0, 4, 1):
-            assert math.isclose(result_serializable['bbox'][i], serialization['bbox'][i], rel_tol=1e-5)
+            assert math.isclose(result_serializable["bbox"][i], serialization["bbox"][i],
+                                rel_tol=1e-5)
         for key in serialization.keys():
-            if key != 'bbox':
+            if key != "bbox":
                 assert result_serializable[key] == serialization[key]
 
 
 class TestRasterSetWriteDescriptor(TestCase):
-    """Test class for the rok4.Raster.RasterSet.write_descriptor(path) class method."""
+    """rok4.Raster.RasterSet.write_descriptor(path) class method."""
 
-    @mock.patch('rok4.Raster.put_data_str')
+    @mock.patch("rok4.Raster.put_data_str")
     def test_ok_with_output_path(self, mocked_put_data_str):
         serialization = {
-            'bbox': [550000.000, 6210000.000, 570000.000, 6230000.000],
-            'colors': [{'bands': 3, 'format': 'UINT8'}],
-            'raster_list': [
-                {'bands': 3, 'bbox': [550000.000, 6210000.000, 560000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/550000_6220000.msk', 'path': 's3://rok4bucket/images/550000_6220000.tif'},
-                {'bands': 3, 'bbox': [560000.000, 6210000.000, 570000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/560000_6220000.msk', 'path': 's3://rok4bucket/images/560000_6220000.tif'},
-                {'bands': 3, 'bbox': [550000.000, 6220000.000, 560000.000, 6230000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/550000_6230000.msk', 'path': 's3://rok4bucket/images/550000_6230000.tif'}
+            "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
+            "colors": [{"bands": 3, "format": "UINT8"}],
+            "raster_list": [
+                {
+                    "bands": 3,
+                    "bbox": [550000.000, 6210000.000, 560000.000, 6220000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "s3://rok4bucket/images/550000_6220000.msk",
+                    "path": "s3://rok4bucket/images/550000_6220000.tif"
+                },
+                {
+                    "bands": 3,
+                    "bbox": [560000.000, 6210000.000, 570000.000, 6220000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "s3://rok4bucket/images/560000_6220000.msk",
+                    "path": "s3://rok4bucket/images/560000_6220000.tif"
+                },
+                {
+                    "bands": 3,
+                    "bbox": [550000.000, 6220000.000, 560000.000, 6230000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "s3://rok4bucket/images/550000_6230000.msk",
+                    "path": "s3://rok4bucket/images/550000_6230000.tif"
+                }
             ],
-            'srs': 'IGNF:LAMB93'
+            "srs": "IGNF:LAMB93"
         }
         content = json.dumps(serialization, sort_keys=True)
-        path = 's3://rok4bucket/dst_descriptor.json'
+        path = "s3://rok4bucket/dst_descriptor.json"
 
         try:
             rasterset = RasterSet()
-            rasterset.bbox = tuple(serialization['bbox'])
-            rasterset.srs = serialization['srs']
+            rasterset.bbox = tuple(serialization["bbox"])
+            rasterset.srs = serialization["srs"]
             rasterset.colors = []
-            for color_dict in serialization['colors']:
-                rasterset.colors.append({'bands': color_dict['bands'], 'format': ColorFormat[ color_dict['format'] ]})
+            for color_dict in serialization["colors"]:
+                rasterset.colors.append({"bands": color_dict["bands"],
+                                         "format": ColorFormat[color_dict["format"]]})
             rasterset.raster_list = []
-            for raster_dict in serialization['raster_list']:
+            for raster_dict in serialization["raster_list"]:
                 raster_args = copy.deepcopy(raster_dict)
-                raster_args['format'] = ColorFormat[ raster_dict['format'] ]
-                raster_args['bbox'] = tuple(raster_dict['bbox'])
-                raster_args['dimensions'] = tuple(raster_dict['dimensions'])
+                raster_args["format"] = ColorFormat[raster_dict["format"]]
+                raster_args["bbox"] = tuple(raster_dict["bbox"])
+                raster_args["dimensions"] = tuple(raster_dict["dimensions"])
                 rasterset.raster_list.append(MagicMock(Raster, **raster_args))
 
             rasterset.write_descriptor(path)
@@ -377,45 +459,60 @@ def test_ok_with_output_path(self, mocked_put_data_str):
         mocked_put_data_str.assert_called_once_with(content, path)
 
 
-    @mock.patch('rok4.Raster.print')
+    @mock.patch("rok4.Raster.print")
     def test_ok_no_output_path(self, mocked_print):
         serialization = {
-            'bbox': [550000.000, 6210000.000, 570000.000, 6230000.000],
-            'colors': [{'bands': 3, 'format': 'UINT8'}],
-            'raster_list': [
-                {'bands': 3, 'bbox': [550000.000, 6210000.000, 560000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/550000_6220000.msk', 'path': 's3://rok4bucket/images/550000_6220000.tif'},
-                {'bands': 3, 'bbox': [560000.000, 6210000.000, 570000.000, 6220000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/560000_6220000.msk', 'path': 's3://rok4bucket/images/560000_6220000.tif'},
-                {'bands': 3, 'bbox': [550000.000, 6220000.000, 560000.000, 6230000.000], 'dimensions': [5000,5000], 'format': 'UINT8', 'mask': 's3://rok4bucket/images/550000_6230000.msk', 'path': 's3://rok4bucket/images/550000_6230000.tif'}
+            "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
+            "colors": [{"bands": 3, "format": "UINT8"}],
+            "raster_list": [
+                {
+                    "bands": 3,
+                    "bbox": [550000.000, 6210000.000, 560000.000, 6220000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "s3://rok4bucket/images/550000_6220000.msk",
+                    "path": "s3://rok4bucket/images/550000_6220000.tif"
+                },
+                {
+                    "bands": 3,
+                    "bbox": [560000.000, 6210000.000, 570000.000, 6220000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "s3://rok4bucket/images/560000_6220000.msk",
+                    "path": "s3://rok4bucket/images/560000_6220000.tif"
+                },
+                {
+                    "bands": 3,
+                    "bbox": [550000.000, 6220000.000, 560000.000, 6230000.000],
+                    "dimensions": [5000,5000],
+                    "format": "UINT8",
+                    "mask": "s3://rok4bucket/images/550000_6230000.msk",
+                    "path": "s3://rok4bucket/images/550000_6230000.tif"
+                }
             ],
-            'srs': 'IGNF:LAMB93'
+            "srs": "IGNF:LAMB93"
         }
         content = json.dumps(serialization, sort_keys=True)
+        rasterset = RasterSet()
+        rasterset.bbox = tuple(serialization["bbox"])
+        rasterset.srs = serialization["srs"]
+        rasterset.colors = []
+        for color_dict in serialization["colors"]:
+            rasterset.colors.append({"bands": color_dict["bands"],
+                                     "format": ColorFormat[color_dict["format"]]})
+        rasterset.raster_list = []
+        for raster_dict in serialization["raster_list"]:
+            raster_args = copy.deepcopy(raster_dict)
+            raster_args["format"] = ColorFormat[raster_dict["format"]]
+            raster_args["bbox"] = tuple(raster_dict["bbox"])
+            raster_args["dimensions"] = tuple(raster_dict["dimensions"])
+            rasterset.raster_list.append(MagicMock(Raster, **raster_args))
 
         try:
-            rasterset = RasterSet()
-            rasterset.bbox = tuple(serialization['bbox'])
-            rasterset.srs = serialization['srs']
-            rasterset.colors = []
-            for color_dict in serialization['colors']:
-                rasterset.colors.append({'bands': color_dict['bands'], 'format': ColorFormat[ color_dict['format'] ]})
-            rasterset.raster_list = []
-            for raster_dict in serialization['raster_list']:
-                raster_args = copy.deepcopy(raster_dict)
-                raster_args['format'] = ColorFormat[ raster_dict['format'] ]
-                raster_args['bbox'] = tuple(raster_dict['bbox'])
-                raster_args['dimensions'] = tuple(raster_dict['dimensions'])
-                rasterset.raster_list.append(MagicMock(Raster, **raster_args))
-
             rasterset.write_descriptor()
-
         except Exception as exc:
             assert False, f"Writing RasterSet's descriptor raises an exception: {exc}"
 
         mocked_print.assert_called_once_with(content)
 
 
-
-class TestRasterSetWriteVRT(TestCase):
-    """Test class for the rok4.Raster.RasterSet.write_vrt(path) class constructor."""
-
-        

From dc40fad4ccd3fbbaf5d21684c6ba4655cb247f57 Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Thu, 4 May 2023 15:08:09 +0200
Subject: [PATCH 37/89] =?UTF-8?q?Suite=20de=20l'homog=C3=A9n=C3=A9isation?=
 =?UTF-8?q?=20et=20de=20la=20mise=20en=20conformit=C3=A9=20du=20code=20li?=
 =?UTF-8?q?=C3=A9=20=C3=A0=20lib=5Fraster=20avec=20PEP-8.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/Raster.py   |  12 +-
 src/rok4/Utils.py    |   6 +-
 tests/test_Raster.py | 481 ++++++++++++++++++++++---------------------
 3 files changed, 251 insertions(+), 248 deletions(-)

diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 7fecad3..1e15602 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -88,7 +88,7 @@ def from_file(cls, path: str) -> "Raster":
         path_pattern = re.compile("(/[^/]+?)[.][a-zA-Z0-9_-]+$")
         mask_path = path_pattern.sub("\\1.msk", path)
 
-        if exists(mask_path):            
+        if exists(mask_path):
             work_mask_path = get_osgeo_path(mask_path)
             mask_driver = gdal.IdentifyDriver(work_mask_path).ShortName
             if 'GTiff' != mask_driver:
@@ -123,13 +123,13 @@ def from_parameters(
             format (ColorFormat): numeric format for color values.
               Bit depth, as bits per channel, can be derived from it.
             mask (str, optionnal): path to the associated mask, if any,
-              or None (same path as the image, but with a 
+              or None (same path as the image, but with a
               ".msk" extension and TIFF format. ex:
               file:///path/to/image.msk or s3://bucket/image.msk)
 
         Examples:
 
-            Loading informations from parameters, related to 
+            Loading informations from parameters, related to
               a TIFF main image coupled to a TIFF mask image
 
                 from rok4.Raster import Raster
@@ -179,16 +179,16 @@ class RasterSet:
                 format (ColorFormat): numeric variable format for
                   color values. Bit depth, as bits per channel,
                   can be derived from it.
-        srs (str): Name of the set's spatial reference system 
+        srs (str): Name of the set's spatial reference system
         bbox (Tuple[float, float, float, float]): bounding rectange
           in the data projection, enclosing the whole set
     """
 
     def __init__(self) -> None:
-        self.raster_list = []
+        self.bbox = (None, None, None, None)
         self.colors = []
+        self.raster_list = []
         self.srs = None
-        self.bbox = (None, None, None, None)
 
     @classmethod
     def from_list(cls, path: str, srs: str) -> "RasterSet":
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 6f8c7a7..b1af301 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -15,7 +15,9 @@
 
 class ColorFormat(Enum):
     """A color format enumeration.
-    Except from "BIT", the member's name matches a common variable format name. The member's value is the allocated bit size associated to this format.
+    Except from "BIT", the member's name matches
+      a common variable format name. The member's value is
+      the allocated bit size associated to this format.
     """
     BIT = 1
     UINT8 = 8
@@ -212,7 +214,7 @@ def compute_bbox(source_dataset: gdal.Dataset) -> Tuple:
             max(y_range),
             max(x_range)
         )
-    elif spatial_ref is None or spatial_ref.GetDataAxisToSRSAxisMapping() == [1, 2]:
+    else:
         # Coordonnées terrain de type (longitude, latitude) ou pas de SRS
         # => les coordonnées terrain sont dans le même ordre que celle de l'image
         bbox = (
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 0cd92b7..72809f9 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -1,20 +1,42 @@
-"""Describes unit tests for the rok4.Raster module."""
+"""Describes unit tests for the rok4.Raster module.
 
-from rok4.Raster import Raster, RasterSet
-from rok4.Utils import ColorFormat
+There is one test class for each tested functionnality.
+See internal docstrings for more information.
+Each variable prefixed by "m_" is a mock, or part of it.
+"""
 
 import copy
 import math
 import json
 import random
-
 import pytest
 from unittest import mock, TestCase
-from unittest.mock import *
+from unittest.mock import call, MagicMock, Mock, mock_open, patch
+
+from rok4.Raster import Raster, RasterSet
+from rok4.Utils import ColorFormat
 
 
 # rok4.Raster.Raster class tests
 
+
+class TestRasterInit(TestCase):
+    """rok4.Raster.Raster default constructor."""
+
+    def test_default(self):
+        """Default property values."""
+        raster = Raster()
+
+        assert raster.bands is None
+        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
+                and all(coordinate is None for coordinate in raster.bbox))
+        assert (isinstance(raster.dimensions, tuple) and len(raster.dimensions) == 2
+                and all(dimension is None for dimension in raster.dimensions))
+        assert raster.format is None
+        assert raster.mask is None
+        assert raster.path is None
+
+
 class TestRasterFromFile(TestCase):
     """rok4.Raster.Raster.from_file(path) class constructor."""
 
@@ -29,56 +51,47 @@ def setUp(self):
 
     def test_empty(self):
         """Constructor called without the expected path argument."""
-
         with pytest.raises(TypeError):
             Raster.from_file()
 
     @mock.patch("rok4.Raster.exists", return_value=False)
-    def test_image_not_found(self, mocked_exists):
+    def test_image_not_found(self, m_exists):
         """Constructor called on a path matching no file or object."""
-
         with pytest.raises(Exception):
             Raster.from_file(self.source_image_path)
-
-        mocked_exists.assert_called_once_with(self.source_image_path)
+        m_exists.assert_called_once_with(self.source_image_path)
 
     @mock.patch("rok4.Raster.get_osgeo_path")
     @mock.patch("rok4.Raster.compute_format", return_value=ColorFormat.UINT8)
     @mock.patch("rok4.Raster.gdal.Open")
     @mock.patch("rok4.Raster.compute_bbox")
     @mock.patch("rok4.Raster.exists", side_effect=[True, False])
-    def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open,
-                   mocked_compute_format, mocked_get_osgeo_path):
+    def test_image(self, m_exists, m_compute_bbox, m_gdal_open, m_compute_format,
+                   m_get_osgeo_path):
         """Constructor called nominally on an image without mask."""
-
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_gdal_open.return_value = type(
-            "", (object,), 
-            {
-                "RasterCount": 3,
-                "RasterXSize": self.image_size[0],
-                "RasterYSize": self.image_size[1]
-            }
-        )
-        mocked_get_osgeo_path.return_value = self.osgeo_image_path
-
-        raster_object = Raster.from_file(self.source_image_path)
-
-        mocked_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
-        mocked_get_osgeo_path.assert_called_once_with(self.source_image_path)
-        mocked_gdal_open.assert_called_once_with( self.osgeo_image_path )
-        assert raster_object.path == self.source_image_path
-        assert raster_object.mask is None
-
-        mocked_compute_bbox.assert_called_once()
-        assert math.isclose(raster_object.bbox[0], self.bbox[0], rel_tol=1e-5)
-        assert math.isclose(raster_object.bbox[1], self.bbox[1], rel_tol=1e-5)
-        assert math.isclose(raster_object.bbox[2], self.bbox[2], rel_tol=1e-5)
-        assert math.isclose(raster_object.bbox[3], self.bbox[3], rel_tol=1e-5)
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-        assert raster_object.dimensions == self.image_size
+        m_compute_bbox.return_value = self.bbox
+        m_dataset_properties = {"RasterCount": 3, "RasterXSize": self.image_size[0],
+                                "RasterYSize": self.image_size[1]}
+        m_gdal_open.return_value = type("", (object,), m_dataset_properties)
+        m_get_osgeo_path.return_value = self.osgeo_image_path
+
+        raster = Raster.from_file(self.source_image_path)
+
+        m_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
+        m_get_osgeo_path.assert_called_once_with(self.source_image_path)
+        m_gdal_open.assert_called_once_with(self.osgeo_image_path)
+        assert raster.path == self.source_image_path
+        assert raster.mask is None
+        m_compute_bbox.assert_called_once()
+        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
+                and math.isclose(raster.bbox[0], self.bbox[0], rel_tol=1e-5)
+                and math.isclose(raster.bbox[1], self.bbox[1], rel_tol=1e-5)
+                and math.isclose(raster.bbox[2], self.bbox[2], rel_tol=1e-5)
+                and math.isclose(raster.bbox[3], self.bbox[3], rel_tol=1e-5))
+        assert raster.bands == 3
+        m_compute_format.assert_called_once()
+        assert raster.format == ColorFormat.UINT8
+        assert raster.dimensions == self.image_size
 
     @mock.patch("rok4.Raster.get_osgeo_path")
     @mock.patch("rok4.Raster.compute_format", return_value=ColorFormat.UINT8)
@@ -86,80 +99,68 @@ def test_image(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open,
     @mock.patch("rok4.Raster.gdal.Open")
     @mock.patch("rok4.Raster.compute_bbox")
     @mock.patch("rok4.Raster.exists", side_effect=[True, True])
-    def test_image_and_mask(self, mocked_exists, mocked_compute_bbox, mocked_gdal_open,
-                            mocked_identifydriver, mocked_compute_format, mocked_get_osgeo_path):
+    def test_image_and_mask(self, m_exists, m_compute_bbox, m_gdal_open, m_identifydriver,
+                            m_compute_format, m_get_osgeo_path):
         """Constructor called nominally on an image with mask."""
+        m_compute_bbox.return_value = self.bbox
+        m_dataset_properties = {"RasterCount": 3, "RasterXSize": self.image_size[0],
+                                "RasterYSize": self.image_size[1]}
+        m_gdal_open.return_value = type("", (object,), m_dataset_properties)
+        m_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
+        m_identifydriver.return_value = type("", (object,), {"ShortName": "GTiff"})
 
-        mocked_compute_bbox.return_value = self.bbox
-        mocked_gdal_open.return_value = type(
-            "",
-            (object,),
-            {
-                "RasterCount": 3,
-                "RasterXSize": self.image_size[0],
-                "RasterYSize": self.image_size[1]
-            }
-        )
-        mocked_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type("", (object,), {"ShortName": "GTiff"})
-
-        raster_object = Raster.from_file(self.source_image_path)
+        raster = Raster.from_file(self.source_image_path)
 
-        mocked_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
-        mocked_get_osgeo_path.assert_has_calls([call(self.source_image_path),
+        m_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
+        m_get_osgeo_path.assert_has_calls([call(self.source_image_path),
                                                 call(self.source_mask_path)])
-        mocked_identifydriver.assert_called_once_with(self.osgeo_mask_path)
-        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
-        assert raster_object.path == self.source_image_path
-        assert raster_object.mask == self.source_mask_path
-
-        mocked_compute_bbox.assert_called_once()
-        assert math.isclose(raster_object.bbox[0], self.bbox[0], rel_tol=1e-5)
-        assert math.isclose(raster_object.bbox[1], self.bbox[1], rel_tol=1e-5)
-        assert math.isclose(raster_object.bbox[2], self.bbox[2], rel_tol=1e-5)
-        assert math.isclose(raster_object.bbox[3], self.bbox[3], rel_tol=1e-5)
-        assert raster_object.bands == 3
-        mocked_compute_format.assert_called_once()
-        assert raster_object.format == ColorFormat.UINT8
-        assert raster_object.dimensions == self.image_size
+        m_identifydriver.assert_called_once_with(self.osgeo_mask_path)
+        m_gdal_open.assert_called_once_with(self.osgeo_image_path)
+        assert raster.path == self.source_image_path
+        assert raster.mask == self.source_mask_path
+        m_compute_bbox.assert_called_once()
+        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
+                and math.isclose(raster.bbox[0], self.bbox[0], rel_tol=1e-5)
+                and math.isclose(raster.bbox[1], self.bbox[1], rel_tol=1e-5)
+                and math.isclose(raster.bbox[2], self.bbox[2], rel_tol=1e-5)
+                and math.isclose(raster.bbox[3], self.bbox[3], rel_tol=1e-5))
+        assert raster.bands == 3
+        m_compute_format.assert_called_once()
+        assert raster.format == ColorFormat.UINT8
+        assert raster.dimensions == self.image_size
 
     @mock.patch("rok4.Raster.get_osgeo_path")
     @mock.patch("rok4.Raster.gdal.Open", side_effect=RuntimeError)
     @mock.patch("rok4.Raster.exists", side_effect=[True, False])
-    def test_unsupported_image_format(self, mocked_exists, mocked_gdal_open, 
-                                      mocked_get_osgeo_path):
+    def test_unsupported_image_format(self, m_exists, m_gdal_open, m_get_osgeo_path):
         """Test case : Constructor called on an unsupported image file or object."""
-
-        mocked_get_osgeo_path.return_value = self.osgeo_image_path
+        m_get_osgeo_path.return_value = self.osgeo_image_path
 
         with pytest.raises(RuntimeError):
             Raster.from_file(self.source_image_path)
 
-        mocked_exists.assert_called_once_with(self.source_image_path)
-        mocked_get_osgeo_path.assert_called_once_with(self.source_image_path)
-        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
+        m_exists.assert_called_once_with(self.source_image_path)
+        m_get_osgeo_path.assert_called_once_with(self.source_image_path)
+        m_gdal_open.assert_called_once_with(self.osgeo_image_path)
 
     @mock.patch("rok4.Raster.get_osgeo_path")
     @mock.patch("rok4.Raster.gdal.IdentifyDriver")
     @mock.patch("rok4.Raster.gdal.Open", side_effect=None)
     @mock.patch("rok4.Raster.exists", side_effect=[True, True])
-    def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_identifydriver,
-                                     mocked_get_osgeo_path):
+    def test_unsupported_mask_format(self, m_exists, m_gdal_open, m_identifydriver,
+                                     m_get_osgeo_path):
         """Test case : Constructor called on an unsupported mask file or object."""
-
-        mocked_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
-        # This next line emulates the return of gdal.IdentifyDriver()
-        mocked_identifydriver.return_value = type("", (object,), {"ShortName": "JPG"})
+        m_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
+        m_identifydriver.return_value = type("", (object,), {"ShortName": "JPG"})
 
         with pytest.raises(Exception):
-            Raster.from_file(self.source_image_path)      
+            Raster.from_file(self.source_image_path)
 
-        mocked_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
-        mocked_get_osgeo_path.assert_has_calls([call(self.source_image_path),
+        m_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
+        m_get_osgeo_path.assert_has_calls([call(self.source_image_path),
                                                 call(self.source_mask_path)])
-        mocked_identifydriver.assert_called_once_with(self.osgeo_mask_path)
-        mocked_gdal_open.assert_called_once_with(self.osgeo_image_path)
+        m_identifydriver.assert_called_once_with(self.osgeo_mask_path)
+        m_gdal_open.assert_called_once_with(self.osgeo_image_path)
 
 
 class TestRasterFromParameters(TestCase):
@@ -167,75 +168,88 @@ class TestRasterFromParameters(TestCase):
 
     def test_image(self):
         """Parameters describing an image without mask"""
+        parameters = {
+            "bands": 4,
+            "bbox": (-5.4, 41.3, 9.8, 51.3),
+            "dimensions": (1920, 1080),
+            "format": ColorFormat.UINT8,
+            "path": "file:///path/to/image.tif"
+        }
+
+        raster = Raster.from_parameters(**parameters)
 
-        i_path = "file:///path/to/image.tif"
-        i_bbox = (-5.4, 41.3, 9.8, 51.3)
-        i_bands = 4
-        i_format = ColorFormat.UINT8
-        i_dimensions = (1920, 1080)
-
-        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format,
-                                        dimensions=i_dimensions)
-
-        assert result.path == i_path
-        assert math.isclose(result.bbox[0], i_bbox[0], rel_tol=1e-5)
-        assert math.isclose(result.bbox[1], i_bbox[1], rel_tol=1e-5)
-        assert math.isclose(result.bbox[2], i_bbox[2], rel_tol=1e-5)
-        assert math.isclose(result.bbox[3], i_bbox[3], rel_tol=1e-5)
-        assert result.bands == i_bands
-        assert result.format == i_format
-        assert result.dimensions == i_dimensions
-        assert result.mask is None
+        assert raster.path == parameters["path"]
+        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
+                and math.isclose(raster.bbox[0], parameters["bbox"][0], rel_tol=1e-5)
+                and math.isclose(raster.bbox[1], parameters["bbox"][1], rel_tol=1e-5)
+                and math.isclose(raster.bbox[2], parameters["bbox"][2], rel_tol=1e-5)
+                and math.isclose(raster.bbox[3], parameters["bbox"][3], rel_tol=1e-5))
+        assert raster.bands == parameters["bands"]
+        assert raster.format == parameters["format"]
+        assert raster.dimensions == parameters["dimensions"]
+        assert raster.mask is None
 
     def test_image_and_mask(self):
         """Parameters describing an image with mask"""
+        parameters = {
+            "bands": 4,
+            "bbox": (-5.4, 41.3, 9.8, 51.3),
+            "dimensions": (1920, 1080),
+            "format": ColorFormat.UINT8,
+            "mask": "file:///path/to/image.msk",
+            "path": "file:///path/to/image.tif"
+        }
+
+        raster = Raster.from_parameters(**parameters)
+
+        assert raster.path == parameters["path"]
+        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
+                and math.isclose(raster.bbox[0], parameters["bbox"][0], rel_tol=1e-5)
+                and math.isclose(raster.bbox[1], parameters["bbox"][1], rel_tol=1e-5)
+                and math.isclose(raster.bbox[2], parameters["bbox"][2], rel_tol=1e-5)
+                and math.isclose(raster.bbox[3], parameters["bbox"][3], rel_tol=1e-5))
+        assert raster.bands == parameters["bands"]
+        assert raster.format == parameters["format"]
+        assert raster.dimensions == parameters["dimensions"]
+        assert raster.mask == parameters["mask"]
 
-        i_path = "file:///path/to/image.tif"
-        i_mask = "file:///path/to/image.msk"
-        i_bbox = (-5.4, 41.3, 9.8, 51.3)
-        i_bands = 4
-        i_format = ColorFormat.UINT8
-        i_dimensions = (1920, 1080)
-
-        result = Raster.from_parameters(path=i_path, bbox=i_bbox, bands=i_bands, format=i_format,
-                                        dimensions=i_dimensions, mask=i_mask)
-
-        assert result.path == i_path
-        assert math.isclose(result.bbox[0], i_bbox[0], rel_tol=1e-5)
-        assert math.isclose(result.bbox[1], i_bbox[1], rel_tol=1e-5)
-        assert math.isclose(result.bbox[2], i_bbox[2], rel_tol=1e-5)
-        assert math.isclose(result.bbox[3], i_bbox[3], rel_tol=1e-5)
-        assert result.bands == i_bands
-        assert result.format == i_format
-        assert result.dimensions == i_dimensions
-        assert result.mask == i_mask
-    
 
 # rok4.Raster.RasterSet class tests
 
+
+class TestRasterSetInit(TestCase):
+    """rok4.Raster.RasterSet default constructor."""
+
+    def test_default(self):
+        """Default property values."""
+        rasterset = RasterSet()
+
+        assert (isinstance(rasterset.bbox, tuple) and len(rasterset.bbox) == 4
+                and all(coordinate is None for coordinate in rasterset.bbox))
+        assert (isinstance(rasterset.colors, list) and not rasterset.colors)
+        assert (isinstance(rasterset.raster_list, list) and not rasterset.raster_list)
+        assert rasterset.srs is None
+
+
 class TestRasterSetFromList(TestCase):
     """rok4.Raster.RasterSet.from_list(path, srs) class constructor."""
 
     @mock.patch("rok4.Raster.get_osgeo_path")
     @mock.patch("rok4.Raster.Raster.from_file")
-    def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
+    def test_ok_at_least_3_files(self, m_from_file, m_get_osgeo_path):
         """List of 3 or more valid image files"""
-
         file_number = random.randint(3, 100)
         file_list = []
         for n in range(0, file_number, 1):
             file_list.append(f"s3://test_bucket/image_{n+1}.tif")
         file_list_string = "\n".join(file_list)
-        mocked_open = mock_open(read_data = file_list_string)
-
+        m_open = mock_open(read_data = file_list_string)
         list_path = "s3://test_bucket/raster_set.list"
         list_local_path = "/tmp/raster_set.list"
-        
-        mocked_get_osgeo_path.return_value = list_local_path
-
+        m_get_osgeo_path.return_value = list_local_path
         raster_list = []
         colors = []
-        serializable = {
+        serial_in = {
             "raster_list": [],
             "colors": []
         }
@@ -250,64 +264,56 @@ def test_ok_at_least_3_files(self, mocked_from_file, mocked_get_osgeo_path):
             )
             raster.format = random.choice([ColorFormat.BIT, ColorFormat.UINT8,
                                           ColorFormat.FLOAT32])
-
             if raster.format == ColorFormat.BIT:
                 raster.bands = 1
             else:
                 raster.bands = random.randint(1, 4)
-
             if random.randint(0, 1) == 1:
                 raster.mask = raster.path.replace(".tif", ".msk")
             else:
                 raster.mask = None
-            
             color_dict = {"bands": raster.bands, "format": raster.format}
             if color_dict not in colors:
                 colors.append(color_dict)
-                serializable["colors"].append({"bands": raster.bands, 
+                serial_in["colors"].append({"bands": raster.bands,
                                                "format": raster.format.name})
             raster.dimensions = (5000, 5000)
-
             raster_list.append(raster)
-            raster_serializable = {"path": raster.path, "bands": raster.bands,
+            raster_serial = {"path": raster.path, "bands": raster.bands,
                                    "format": raster.format.name, "bbox": list(raster.bbox),
                                    "dimensions": list(raster.dimensions)}
-            if raster.mask: 
-                raster_serializable["mask"] = raster.mask
-            serializable["raster_list"].append(raster_serializable)
-
-        mocked_from_file.side_effect = raster_list
-
+            if raster.mask:
+                raster_serial["mask"] = raster.mask
+            serial_in["raster_list"].append(raster_serial)
+        m_from_file.side_effect = raster_list
         srs = "EPSG:4326"
-        serializable["srs"] = srs
+        serial_in["srs"] = srs
         bbox = (
             -0.75,
             -1.33,
             0.25 + math.floor((file_number-1)/3),
             1.67
         )
-        serializable["bbox"] = list(bbox)
-
-        with mock.patch("rok4.Raster.open", mocked_open):
-            result = RasterSet.from_list(list_path, srs)
+        serial_in["bbox"] = list(bbox)
 
-        result_serializable = result.serializable
+        with mock.patch("rok4.Raster.open", m_open):
+            rasterset = RasterSet.from_list(list_path, srs)
 
-        assert result.srs == srs
-        mocked_get_osgeo_path.assert_called_once_with(list_path)
-        mocked_open.assert_called_once_with(file=list_local_path, mode="r")
-        assert result.raster_list == raster_list
-        assert isinstance(result_serializable["bbox"], list)
+        serial_out = rasterset.serializable
+        assert rasterset.srs == srs
+        m_get_osgeo_path.assert_called_once_with(list_path)
+        m_open.assert_called_once_with(file=list_local_path, mode="r")
+        assert rasterset.raster_list == raster_list
+        assert isinstance(serial_out["bbox"], list)
         for i in range(0, 4, 1):
-            assert math.isclose(result.bbox[i], bbox[i], rel_tol=1e-5)
-            assert math.isclose(result_serializable["bbox"][i], serializable["bbox"][i],
-                                rel_tol=1e-5)
-        assert len(result.colors) > 0
-        assert result.colors == colors
-        for key in serializable.keys():
+            assert math.isclose(rasterset.bbox[i], bbox[i], rel_tol=1e-5)
+            assert math.isclose(serial_out["bbox"][i], serial_in["bbox"][i], rel_tol=1e-5)
+        assert len(rasterset.colors) > 0
+        assert rasterset.colors == colors
+        for key in serial_in.keys():
             if key != "bbox":
-                assert result_serializable[key] == serializable[key]
-        assert isinstance(result_serializable["bbox"], list)
+                assert serial_out[key] == serial_in[key]
+        assert isinstance(serial_out["bbox"], list)
 
 
 class TestRasterSetFromDescriptor(TestCase):
@@ -315,15 +321,15 @@ class TestRasterSetFromDescriptor(TestCase):
 
     @mock.patch("rok4.Raster.get_osgeo_path")
     @mock.patch("rok4.Raster.Raster.from_parameters")
-    def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
-        serialization = {
+    def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
+        serial_in = {
             "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
             "colors": [{"bands": 3, "format": "UINT8"}],
             "raster_list": [
                 {
                     "bands": 3,
                     "bbox": [550000.000, 6210000.000, 560000.000, 6220000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "file:///path/to/images/550000_6220000.msk",
                     "path": "file:///path/to/images/550000_6220000.tif"
@@ -331,7 +337,7 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
                 {
                     "bands": 3,
                     "bbox": [560000.000, 6210000.000, 570000.000, 6220000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "file:///path/to/images/560000_6220000.msk",
                     "path": "file:///path/to/images/560000_6220000.tif"
@@ -339,7 +345,7 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
                 {
                     "bands": 3,
                     "bbox": [550000.000, 6220000.000, 560000.000, 6230000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "file:///path/to/images/550000_6230000.msk",
                     "path": "file:///path/to/images/550000_6230000.tif"
@@ -349,11 +355,10 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
         }
         desc_path = "file:///path/to/descriptor.json"
         local_path = "/path/to/descriptor.json"
-        desc_content = json.dumps(serialization)
-
+        desc_content = json.dumps(serial_in)
         raster_list = []
         raster_args_list = []
-        for raster_dict in serialization["raster_list"]:
+        for raster_dict in serial_in["raster_list"]:
             raster_properties = copy.deepcopy(raster_dict)
             raster_properties["format"] = ColorFormat[raster_dict["format"]]
             raster_properties["bbox"] = tuple(raster_dict["bbox"])
@@ -362,53 +367,51 @@ def test_simple_ok(self, mocked_from_parameters, mocked_get_osgeo_path):
             raster = MagicMock(Raster, **raster_properties)
             raster_list.append(raster)
             raster_args_list.append(raster_properties)
-
-        mocked_from_parameters.side_effect = raster_list
-        mocked_get_osgeo_path.return_value = local_path
-        mocked_open = mock_open(read_data = desc_content)
-        with mock.patch("rok4.Raster.open", mocked_open):
-            result = RasterSet.from_descriptor(desc_path)
-
-        mocked_get_osgeo_path.assert_called_once_with(desc_path)
-        mocked_open.assert_called_once_with(file=local_path, mode="r")
-        assert result.srs == serialization["srs"]
-        mocked_from_parameters.assert_called()
-        assert mocked_from_parameters.call_count == 3
+        m_from_parameters.side_effect = raster_list
+        m_get_osgeo_path.return_value = local_path
+        m_open = mock_open(read_data = desc_content)
+
+        with mock.patch("rok4.Raster.open", m_open):
+            rasterset = RasterSet.from_descriptor(desc_path)
+
+        m_get_osgeo_path.assert_called_once_with(desc_path)
+        m_open.assert_called_once_with(file=local_path, mode="r")
+        assert rasterset.srs == serial_in["srs"]
+        m_from_parameters.assert_called()
+        assert m_from_parameters.call_count == 3
         for i in range(0, len(raster_args_list), 1):
-            assert mocked_from_parameters.call_args_list[i] == call(**raster_args_list[i])
-        assert result.raster_list == raster_list
-        assert isinstance(result.bbox, tuple)
-        for i in range(0, 4, 1):
-            assert math.isclose(result.bbox[i], serialization["bbox"][i], rel_tol=1e-5)
-        assert len(result.colors) > 0
-        for i in range(0, len(serialization["colors"]), 1):
-            expected_color = copy.deepcopy(serialization["colors"][i])
-            expected_color["format"] = ColorFormat[serialization["colors"][i]["format"]]
-            assert result.colors[i] == expected_color
-
-        result_serializable = result.serializable
-        assert isinstance(result_serializable["bbox"], list)
+            assert m_from_parameters.call_args_list[i] == call(**raster_args_list[i])
+        assert rasterset.raster_list == raster_list
+        assert (isinstance(rasterset.bbox, tuple) and len(rasterset.bbox) == 4)
+        assert isinstance(rasterset.colors, list) and rasterset.colors
+        for i in range(0, len(serial_in["colors"]), 1):
+            expected_color = copy.deepcopy(serial_in["colors"][i])
+            expected_color["format"] = ColorFormat[serial_in["colors"][i]["format"]]
+            assert rasterset.colors[i] == expected_color
+        serial_out = rasterset.serializable
+        assert (isinstance(serial_out["bbox"], list)
+                and len(serial_out["bbox"]) == 4)
         for i in range(0, 4, 1):
-            assert math.isclose(result_serializable["bbox"][i], serialization["bbox"][i],
-                                rel_tol=1e-5)
-        for key in serialization.keys():
+            assert math.isclose(rasterset.bbox[i], serial_in["bbox"][i], rel_tol=1e-5)
+            assert math.isclose(serial_out["bbox"][i], serial_in["bbox"][i], rel_tol=1e-5)
+        for key in serial_in.keys():
             if key != "bbox":
-                assert result_serializable[key] == serialization[key]
+                assert serial_out[key] == serial_in[key]
 
 
 class TestRasterSetWriteDescriptor(TestCase):
     """rok4.Raster.RasterSet.write_descriptor(path) class method."""
 
     @mock.patch("rok4.Raster.put_data_str")
-    def test_ok_with_output_path(self, mocked_put_data_str):
-        serialization = {
+    def test_ok_with_output_path(self, m_put_data_str):
+        serial_in = {
             "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
             "colors": [{"bands": 3, "format": "UINT8"}],
             "raster_list": [
                 {
                     "bands": 3,
                     "bbox": [550000.000, 6210000.000, 560000.000, 6220000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/550000_6220000.msk",
                     "path": "s3://rok4bucket/images/550000_6220000.tif"
@@ -416,7 +419,7 @@ def test_ok_with_output_path(self, mocked_put_data_str):
                 {
                     "bands": 3,
                     "bbox": [560000.000, 6210000.000, 570000.000, 6220000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/560000_6220000.msk",
                     "path": "s3://rok4bucket/images/560000_6220000.tif"
@@ -424,7 +427,7 @@ def test_ok_with_output_path(self, mocked_put_data_str):
                 {
                     "bands": 3,
                     "bbox": [550000.000, 6220000.000, 560000.000, 6230000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/550000_6230000.msk",
                     "path": "s3://rok4bucket/images/550000_6230000.tif"
@@ -432,43 +435,41 @@ def test_ok_with_output_path(self, mocked_put_data_str):
             ],
             "srs": "IGNF:LAMB93"
         }
-        content = json.dumps(serialization, sort_keys=True)
+        content = json.dumps(serial_in, sort_keys=True)
         path = "s3://rok4bucket/dst_descriptor.json"
+        rasterset = RasterSet()
+        rasterset.bbox = tuple(serial_in["bbox"])
+        rasterset.srs = serial_in["srs"]
+        rasterset.colors = []
+        for color_dict in serial_in["colors"]:
+            rasterset.colors.append({"bands": color_dict["bands"],
+                                     "format": ColorFormat[color_dict["format"]]})
+        rasterset.raster_list = []
+        for raster_dict in serial_in["raster_list"]:
+            raster_args = copy.deepcopy(raster_dict)
+            raster_args["format"] = ColorFormat[raster_dict["format"]]
+            raster_args["bbox"] = tuple(raster_dict["bbox"])
+            raster_args["dimensions"] = tuple(raster_dict["dimensions"])
+            rasterset.raster_list.append(MagicMock(Raster, **raster_args))
 
         try:
-            rasterset = RasterSet()
-            rasterset.bbox = tuple(serialization["bbox"])
-            rasterset.srs = serialization["srs"]
-            rasterset.colors = []
-            for color_dict in serialization["colors"]:
-                rasterset.colors.append({"bands": color_dict["bands"],
-                                         "format": ColorFormat[color_dict["format"]]})
-            rasterset.raster_list = []
-            for raster_dict in serialization["raster_list"]:
-                raster_args = copy.deepcopy(raster_dict)
-                raster_args["format"] = ColorFormat[raster_dict["format"]]
-                raster_args["bbox"] = tuple(raster_dict["bbox"])
-                raster_args["dimensions"] = tuple(raster_dict["dimensions"])
-                rasterset.raster_list.append(MagicMock(Raster, **raster_args))
-
             rasterset.write_descriptor(path)
-
         except Exception as exc:
             assert False, f"Writing RasterSet's descriptor raises an exception: {exc}"
 
-        mocked_put_data_str.assert_called_once_with(content, path)
+        m_put_data_str.assert_called_once_with(content, path)
 
 
     @mock.patch("rok4.Raster.print")
-    def test_ok_no_output_path(self, mocked_print):
-        serialization = {
+    def test_ok_no_output_path(self, m_print):
+        serial_in = {
             "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
             "colors": [{"bands": 3, "format": "UINT8"}],
             "raster_list": [
                 {
                     "bands": 3,
                     "bbox": [550000.000, 6210000.000, 560000.000, 6220000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/550000_6220000.msk",
                     "path": "s3://rok4bucket/images/550000_6220000.tif"
@@ -476,7 +477,7 @@ def test_ok_no_output_path(self, mocked_print):
                 {
                     "bands": 3,
                     "bbox": [560000.000, 6210000.000, 570000.000, 6220000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/560000_6220000.msk",
                     "path": "s3://rok4bucket/images/560000_6220000.tif"
@@ -484,7 +485,7 @@ def test_ok_no_output_path(self, mocked_print):
                 {
                     "bands": 3,
                     "bbox": [550000.000, 6220000.000, 560000.000, 6230000.000],
-                    "dimensions": [5000,5000],
+                    "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/550000_6230000.msk",
                     "path": "s3://rok4bucket/images/550000_6230000.tif"
@@ -492,16 +493,16 @@ def test_ok_no_output_path(self, mocked_print):
             ],
             "srs": "IGNF:LAMB93"
         }
-        content = json.dumps(serialization, sort_keys=True)
+        content = json.dumps(serial_in, sort_keys=True)
         rasterset = RasterSet()
-        rasterset.bbox = tuple(serialization["bbox"])
-        rasterset.srs = serialization["srs"]
+        rasterset.bbox = tuple(serial_in["bbox"])
+        rasterset.srs = serial_in["srs"]
         rasterset.colors = []
-        for color_dict in serialization["colors"]:
+        for color_dict in serial_in["colors"]:
             rasterset.colors.append({"bands": color_dict["bands"],
                                      "format": ColorFormat[color_dict["format"]]})
         rasterset.raster_list = []
-        for raster_dict in serialization["raster_list"]:
+        for raster_dict in serial_in["raster_list"]:
             raster_args = copy.deepcopy(raster_dict)
             raster_args["format"] = ColorFormat[raster_dict["format"]]
             raster_args["bbox"] = tuple(raster_dict["bbox"])
@@ -513,6 +514,6 @@ def test_ok_no_output_path(self, mocked_print):
         except Exception as exc:
             assert False, f"Writing RasterSet's descriptor raises an exception: {exc}"
 
-        mocked_print.assert_called_once_with(content)
+        m_print.assert_called_once_with(content)
 
 

From ea98bf1e77b90f5f11712714353d938434807f3f Mon Sep 17 00:00:00 2001
From: Xavier Dumetz <XDmz@protonmail.com>
Date: Wed, 10 May 2023 10:51:11 +0200
Subject: [PATCH 38/89] Retrait des espaces en fin de lignes dans
 'src/rok4/Utils.py'.

---
 src/rok4/Utils.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index b1af301..8e8efca 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -57,7 +57,7 @@ def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
 
     return __SR_BOOK[srs.upper()]
 
-def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int = 0) -> 'osgeo.ogr.Geometry':  
+def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int = 0) -> 'osgeo.ogr.Geometry':
     """Convert bbox coordinates to OGR geometry
 
     Args:
@@ -66,10 +66,10 @@ def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int
 
     Raises:
         RuntimeError: Provided SRS is invalid for OSR
-        
+
     Returns:
         osgeo.ogr.Geometry: Corresponding OGR geometry, with spatial reference if provided
-    """    
+    """
 
     ring = ogr.Geometry(ogr.wkbLinearRing)
 
@@ -93,18 +93,18 @@ def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int
         ring.AddPoint(bbox[2], bbox[3])
         ring.AddPoint(bbox[0], bbox[3])
         ring.AddPoint(bbox[0], bbox[1])
-    
+
 
     geom = ogr.Geometry(ogr.wkbPolygon)
     geom.AddGeometry(ring)
     geom.SetCoordinateDimension(2)
-    
+
     return geom
 
 
 
 def reproject_bbox(bbox: Tuple[float, float, float, float], srs_src: str, srs_dst: str, densification: int = 5) -> Tuple[float, float, float, float]:
-    """Return bounding box in other coordinates system 
+    """Return bounding box in other coordinates system
 
     Points are added to be sure output bounding box contains input bounding box
 
@@ -179,7 +179,7 @@ def compute_bbox(source_dataset: gdal.Dataset) -> Tuple:
     Args:
         source_dataset (gdal.Dataset): Dataset instanciated
           from the raster image
-    
+
     Limitations:
         Image's axis must be parallel to SRS' axis
 

From b196a0dde0226c3fa2e5cd8a84be46b0e9f634fd Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 10 May 2023 17:26:28 +0200
Subject: [PATCH 39/89] Add official git hooks

---
 .pre-commit-config.yaml | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 .pre-commit-config.yaml

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..ddc5f9b
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,22 @@
+exclude: ".venv|__pycache__|tests/dev/|tests/fixtures/"
+fail_fast: false
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: check-added-large-files
+        args: ["--maxkb=1024"]
+      - id: check-ast
+      - id: check-builtin-literals
+      - id: check-case-conflict
+      - id: check-toml
+      - id: check-yaml
+      - id: detect-private-key
+      - id: end-of-file-fixer
+      - id: fix-byte-order-marker
+      - id: fix-encoding-pragma
+        args: [--remove]
+      - id: name-tests-test
+        args: [--pytest-test-first]
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]

From b0d6f95cf245f850d35170bfeeb36905518bb725 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 10 May 2023 17:26:48 +0200
Subject: [PATCH 40/89] Add git hooks to contributing guide and readme

---
 CONTRIBUTING.md | 11 +++++++++++
 README.md       | 10 ++++++++++
 2 files changed, 21 insertions(+)
 create mode 100644 CONTRIBUTING.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..02aa3bf
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,11 @@
+# Directives de contribution
+
+Tout d'abord, merci d'envisager de contribuer à ce projet !
+
+Il s'agit principalement de lignes directrices, et non de règles. Faites preuve de discernement, et n'hésitez pas à proposer des modifications à ce document dans une pull request.
+
+## Git hooks
+
+Nous utilisons les git hooks via [pre-commit](https://pre-commit.com/) pour appliquer et vérifier automatiquement certaines "règles". Veuillez l'installer avant de pousser un commit.
+
+Voir le fichier de configuration correspondant : `.pre-commit-config.yaml`.
diff --git a/README.md b/README.md
index 400645d..4ff3c57 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,16 @@ except Exception as exc:
     print(exc)
 ```
 
+## Contribuer
+
+* Installer les dépendances de développement :
+
+    ```sh
+    python3 -m pip install -e[dev]
+    ```
+
+* Consulter les [directives de contribution](./CONTRIBUTING.md)
+
 ## Compiler la librairie
 
 ```sh

From 3d239d2cc715fa9c59290c3423828933b030c7ea Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Thu, 11 May 2023 15:53:14 +0200
Subject: [PATCH 41/89] Apply basic git hooks

---
 .coveragerc                              |   2 +-
 .github/workflows/build-and-release.yaml |  11 +-
 LICENSE.txt                              |   4 +-
 README.pypi.md                           |   2 +-
 setup.py                                 |   2 +-
 src/rok4/Layer.py                        |  19 ++--
 src/rok4/Pyramid.py                      | 134 +++++++++++------------
 src/rok4/Raster.py                       |   4 +-
 src/rok4/Storage.py                      |  60 +++++-----
 src/rok4/TileMatrixSet.py                |  13 +--
 src/rok4/Utils.py                        |  18 +--
 src/rok4/__init__.py                     |   2 +-
 tests/test_Layer.py                      |   4 +-
 tests/test_Pyramid.py                    |  12 +-
 tests/test_Raster.py                     |   3 +-
 tests/test_Storage.py                    |  72 ++++++------
 tests/test_TileMatrixSet.py              |   2 +-
 tests/test_Utils.py                      |   7 +-
 tests/test_Vector.py                     |   1 -
 19 files changed, 183 insertions(+), 189 deletions(-)

diff --git a/.coveragerc b/.coveragerc
index 7f85b15..5877884 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -1,5 +1,5 @@
 [run]
-include = 
+include =
     */src/*
 omit =
     */__init__.py
diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 40fb13e..b5cc6e6 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -23,8 +23,8 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          tag_name: ${{ github.ref_name }} 
-          release_name: Release ${{ github.ref_name }} 
+          tag_name: ${{ github.ref_name }}
+          release_name: Release ${{ github.ref_name }}
           body_path: CHANGELOG.md
           draft: false
           prerelease: false
@@ -135,7 +135,7 @@ jobs:
           asset_content_type: application/zip
 
       - name: Add tarball package to release
-        id: upload-release-targz 
+        id: upload-release-targz
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -159,7 +159,7 @@ jobs:
   commit_documentation:
     name: Add documentation and unit tests results into gh-pages branch
     needs: build_and_test
-    if: "always()&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')" 
+    if: "always()&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
     runs-on: ubuntu-latest
 
     steps:
@@ -208,7 +208,7 @@ jobs:
   delete_version:
     name: Remove release and tag if error occured
     needs: build_and_test
-    if: "always()&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status!='success')" 
+    if: "always()&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status!='success')"
     runs-on: ubuntu-latest
 
     steps:
@@ -219,4 +219,3 @@ jobs:
           delete_release: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
diff --git a/LICENSE.txt b/LICENSE.txt
index d6eb151..2bb09b4 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -122,7 +122,7 @@ These expressions may be used both in singular and plural form.
 The purpose of the Agreement is the grant by the Licensor to the
 Licensee of a non-exclusive, transferable and worldwide license for the
 Software as set forth in Article 5 hereinafter for the whole term of the
-protection granted by the rights over said Software. 
+protection granted by the rights over said Software.
 
 
     Article 3 - ACCEPTANCE
@@ -268,7 +268,7 @@ When the Licensee creates Derivative Software, this Derivative Software
 may be distributed under a license agreement other than this Agreement,
 subject to compliance with the requirement to include a notice
 concerning the rights over the Software as defined in Article 6.4.
-In the event the creation of the Derivative Software required modification 
+In the event the creation of the Derivative Software required modification
 of the Source Code, the Licensee undertakes that:
 
    1. the resulting Modified Software will be governed by this Agreement,
diff --git a/README.pypi.md b/README.pypi.md
index 1f0bf75..fc3417b 100644
--- a/README.pypi.md
+++ b/README.pypi.md
@@ -24,4 +24,4 @@ except Exception as exc:
     print(exc)
 ```
 
-More examples in the developer documentation
\ No newline at end of file
+More examples in the developer documentation
diff --git a/setup.py b/setup.py
index fc1f76c..6068493 100644
--- a/setup.py
+++ b/setup.py
@@ -1,3 +1,3 @@
 from setuptools import setup
 
-setup()
\ No newline at end of file
+setup()
diff --git a/src/rok4/Layer.py b/src/rok4/Layer.py
index 1c9f7b3..3f421f3 100644
--- a/src/rok4/Layer.py
+++ b/src/rok4/Layer.py
@@ -48,7 +48,7 @@ def from_descriptor(cls, descriptor: str) -> 'Layer':
 
         Returns:
             Layer: a Layer instance
-        """        
+        """
         try:
             data = json.loads(get_data_str(descriptor))
 
@@ -72,7 +72,7 @@ def from_descriptor(cls, descriptor: str) -> 'Layer':
                     layer.__keywords.append(k)
 
 
-            if layer.type == PyramidType.RASTER: 
+            if layer.type == PyramidType.RASTER:
                 if "resampling" in data:
                     layer.__resampling = data["resampling"]
 
@@ -145,7 +145,7 @@ def from_parameters(cls, pyramids: List[Dict[str, str]], name: str, **kwargs) ->
         else:
             layer.__abstract = name
 
-        if layer.type == PyramidType.RASTER: 
+        if layer.type == PyramidType.RASTER:
             if "styles" in kwargs and kwargs["styles"] is not None and len(kwargs["styles"]) > 0:
                 layer.__styles = kwargs["styles"]
             else:
@@ -161,7 +161,7 @@ def __init__(self) -> None:
         self.__format = None
         self.__tms = None
         self.__best_level = None
-        self.__levels = dict()
+        self.__levels = {}
         self.__keywords = []
         self.__pyramids = []
 
@@ -176,7 +176,7 @@ def __load_pyramids(self, pyramids: List[Dict[str, str]]) -> None:
             Exception: Pyramids' do not all own the same TMS
             Exception: Pyramids' do not all own the same channels number
             Exception: Overlapping in usage pyramids' levels
-        """        
+        """
 
         ## Toutes les pyramides doivent avoir les même caractéristiques
         channels = None
@@ -227,12 +227,12 @@ def __str__(self) -> str:
         return f"{self.type.name} layer '{self.__name}'"
 
     @property
-    def serializable(self) -> Dict: 
+    def serializable(self) -> Dict:
         """Get the dict version of the layer object, descriptor compliant
 
         Returns:
             Dict: descriptor structured object description
-        """        
+        """
         serialization = {
             "title": self.__title,
             "abstract": self.__abstract,
@@ -273,7 +273,7 @@ def serializable(self) -> Dict:
 
             if self.__tms.srs.upper() not in serialization["wms"]["crs"]:
                 serialization["wms"]["crs"].append(self.__tms.srs.upper())
-            
+
             serialization["styles"] = self.__styles
             serialization["resampling"] = self.__resampling
 
@@ -284,7 +284,7 @@ def write_descriptor(self, directory: str = None) -> None:
 
         Args:
             directory (str, optional): Directory (file or object) where to print the layer's descriptor, called <layer's name>.json. Defaults to None, JSON is printed to standard output.
-        """        
+        """
         content = json.dumps(self.serializable)
 
         if directory is None:
@@ -306,4 +306,3 @@ def bbox(self) -> Tuple[float, float, float, float]:
     @property
     def geobbox(self) -> Tuple[float, float, float, float]:
         return self.__geobbox
-
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index ab0a885..75b433c 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,35 +275,35 @@ 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"])
         max_bbox = self.__pyramid.tms.get_level(self.__id).tile_to_bbox(self.__tile_limits["max_col"], self.__tile_limits["min_row"])
 
         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:
@@ -325,7 +325,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,
@@ -348,9 +348,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': {
@@ -392,7 +392,7 @@ def from_descriptor(cls, descriptor: str) -> 'Pyramid':
 
         Returns:
             Pyramid: a Pyramid instance
-        """        
+        """
         try:
             data = json.loads(get_data_str(descriptor))
 
@@ -467,7 +467,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
 
@@ -496,25 +496,25 @@ def from_other(cls, other: 'Pyramid', name: str, storage: Dict) -> 'Pyramid':
         return pyramid
 
     def __init__(self) -> None:
-        self.__storage = dict()
-        self.__levels = dict()
+        self.__storage = {}
+        self.__levels = {}
         self.__masks = None
 
         self.__content = {
             "loaded": False,
-            "cache": dict()
+            "cache": {}
         }
 
     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
@@ -549,7 +549,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
@@ -561,34 +561,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)
 
 
@@ -598,7 +598,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]
@@ -617,7 +617,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
@@ -627,11 +627,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"]:
@@ -644,12 +644,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
@@ -658,7 +658,7 @@ def top_level(self) -> 'Level':
 
         Returns:
             Level: the top level
-        """        
+        """
         return sorted(self.__levels.values(), key=lambda l: l.resolution)[-1]
 
     @property
@@ -667,7 +667,7 @@ def type(self) -> PyramidType:
 
         Returns:
             PyramidType: RASTER or VECTOR
-        """        
+        """
         if self.__format == "TIFF_PBF_MVT":
             return PyramidType.VECTOR
         else:
@@ -677,7 +677,7 @@ def load_list(self) -> None:
         """Load list content and cache it
 
         If list is already loaded, nothing done
-        """        
+        """
         if self.__content["loaded"]:
             return
 
@@ -686,7 +686,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
@@ -711,7 +711,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
 
             Value example:
 
-                ( 
+                (
                     (<SlabType.DATA: 'DATA'>, '18', 5424, 7526),
                     {
                         'link': False,
@@ -721,7 +721,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
@@ -733,7 +733,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
             copy(self.__list, f"file://{list_file}")
             list_obj.close()
 
-            roots = dict()
+            roots = {}
             s3_cluster = self.storage_s3_cluster
 
             with open(list_file, "r") as listin:
@@ -741,7 +741,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
 
@@ -787,7 +787,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)
 
 
@@ -830,7 +830,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
@@ -857,19 +857,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)
 
@@ -895,7 +895,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")
@@ -905,7 +905,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("/")
 
@@ -951,17 +951,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
@@ -1012,7 +1012,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")
 
@@ -1037,7 +1037,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:
@@ -1120,12 +1120,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":
@@ -1133,14 +1133,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":
@@ -1152,7 +1152,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:
@@ -1163,14 +1163,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}")
@@ -1279,7 +1279,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")
 
diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 2a06ee6..80c058e 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -79,7 +79,7 @@ def from_file(cls, path: str) -> 'Raster':
         path_pattern = re.compile('(/[^/]+?)[.][a-zA-Z0-9_-]+$')
         mask_path = path_pattern.sub('\\1.msk', path)
 
-        if exists(mask_path):            
+        if exists(mask_path):
             work_mask_path = get_osgeo_path(mask_path)
             mask_driver = gdal.IdentifyDriver(work_mask_path).ShortName
             if 'GTiff' != mask_driver:
@@ -128,7 +128,7 @@ def from_parameters(cls, path: str, bands: int, bbox: Tuple[float, float, float,
         """
 
         self = cls()
-            
+
         self.path = path
         self.bands = bands
         self.bbox = bbox
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index dc19b80..3e22fd3 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -49,7 +49,7 @@ class StorageType(Enum):
     S3 = "s3://"
     CEPH = "ceph://"
 
-__S3_CLIENTS = dict()
+__S3_CLIENTS = {}
 __S3_DEFAULT_CLIENT = None
 def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',str]], str, str]:
     """Get the S3 client
@@ -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,13 +122,13 @@ 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_CLIENTS = {}
     __S3_DEFAULT_CLIENT = None
 
 __CEPH_CLIENT = None
-__CEPH_IOCTXS = dict()
+__CEPH_IOCTXS = {}
 def __get_ceph_ioctx(pool: str) -> 'rados.Ioctx':
     """Get the CEPH IO context
 
@@ -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,15 +166,15 @@ 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()
+    __CEPH_IOCTXS = {}
 
 __OBJECT_SYMLINK_SIGNATURE = "SYMLINK#"
 
@@ -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)
 
diff --git a/src/rok4/TileMatrixSet.py b/src/rok4/TileMatrixSet.py
index 502e74b..80bd570 100644
--- a/src/rok4/TileMatrixSet.py
+++ b/src/rok4/TileMatrixSet.py
@@ -76,7 +76,7 @@ def y_to_row(self, y: float) -> int:
         """
         return int((self.origin[1] - y) / (self.resolution * self.tile_size[1]))
 
-    def tile_to_bbox(self, tile_col: int, tile_row: int) -> Tuple[float, float, float, float]:    
+    def tile_to_bbox(self, tile_col: int, tile_row: int) -> Tuple[float, float, float, float]:
         """Get tile terrain extent (xmin, ymin, xmax, ymax), in TMS coordinates system
 
         TMS spatial reference is Lat / Lon case is handled.
@@ -103,7 +103,7 @@ def tile_to_bbox(self, tile_col: int, tile_row: int) -> Tuple[float, float, floa
                 self.origin[1] - self.resolution * tile_row * self.tile_size[1]
             )
 
-    def bbox_to_tiles(self, bbox: Tuple[float, float, float, float]) -> Tuple[int, int, int, int]:    
+    def bbox_to_tiles(self, bbox: Tuple[float, float, float, float]) -> Tuple[int, int, int, int]:
         """Get extrems tile columns and rows corresponding to provided bounding box
 
         TMS spatial reference is Lat / Lon case is handled.
@@ -141,8 +141,8 @@ def point_to_indices(self, x: float, y: float) -> Tuple[int, int, int, int]:
 
         Returns:
             Tuple[int, int, int, int]: tile's column, tile's row, pixel's (in the tile) column, pixel's row
-        """        
-        
+        """
+
         if self.__latlon:
             absolute_pixel_column = int((y - self.origin[0]) / self.resolution)
             absolute_pixel_row = int((self.origin[1] - x) / self.resolution)
@@ -220,10 +220,9 @@ def get_level(self, level_id: str) -> 'TileMatrix':
         Returns:
             The corresponding tile matrix, None if not present
         """
-      
+
         return self.levels.get(level_id, None)
 
     @property
-    def sorted_levels(self) -> List[TileMatrix]: 
+    def sorted_levels(self) -> List[TileMatrix]:
         return sorted(self.levels.values(), key=lambda l: l.resolution)
-
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index 47e1bcd..0e4c480 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -22,7 +22,7 @@ class ColorFormat(Enum):
     FLOAT32 = 32
 
 
-__SR_BOOK = dict()
+__SR_BOOK = {}
 def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
     """Convert coordinates system as string to OSR spatial reference
 
@@ -55,7 +55,7 @@ def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
 
     return __SR_BOOK[srs.upper()]
 
-def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int = 0) -> 'osgeo.ogr.Geometry':  
+def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int = 0) -> 'osgeo.ogr.Geometry':
     """Convert bbox coordinates to OGR geometry
 
     Args:
@@ -64,10 +64,10 @@ def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int
 
     Raises:
         RuntimeError: Provided SRS is invalid for OSR
-        
+
     Returns:
         osgeo.ogr.Geometry: Corresponding OGR geometry, with spatial reference if provided
-    """    
+    """
 
     ring = ogr.Geometry(ogr.wkbLinearRing)
 
@@ -91,18 +91,18 @@ def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int
         ring.AddPoint(bbox[2], bbox[3])
         ring.AddPoint(bbox[0], bbox[3])
         ring.AddPoint(bbox[0], bbox[1])
-    
+
 
     geom = ogr.Geometry(ogr.wkbPolygon)
     geom.AddGeometry(ring)
     geom.SetCoordinateDimension(2)
-    
+
     return geom
 
 
 
 def reproject_bbox(bbox: Tuple[float, float, float, float], srs_src: str, srs_dst: str, densification: int = 5) -> Tuple[float, float, float, float]:
-    """Return bounding box in other coordinates system 
+    """Return bounding box in other coordinates system
 
     Points are added to be sure output bounding box contains input bounding box
 
@@ -176,7 +176,7 @@ def compute_bbox(source_dataset: gdal.Dataset) -> tuple:
 
     Args:
         source_dataset (gdal.Dataset): Dataset object created from the raster image
-    
+
     Limitations:
         Image's axis must be parallel to SRS' axis
 
@@ -244,7 +244,7 @@ def compute_format(dataset: gdal.Dataset, path: str = None) -> 'ColorFormat':
 
     if dataset.RasterCount < 1:
         raise Exception(f"Image {path} contains no color band.")
-    
+
     band_1_datatype = dataset.GetRasterBand(1).DataType
     data_type_name = gdal.GetDataTypeName(band_1_datatype)
     data_type_size = gdal.GetDataTypeSize(band_1_datatype)
diff --git a/src/rok4/__init__.py b/src/rok4/__init__.py
index 3aa0d7b..6c8e6b9 100644
--- a/src/rok4/__init__.py
+++ b/src/rok4/__init__.py
@@ -1 +1 @@
-__version__ = "0.0.0"
\ No newline at end of file
+__version__ = "0.0.0"
diff --git a/tests/test_Layer.py b/tests/test_Layer.py
index b92f84b..26b0963 100644
--- a/tests/test_Layer.py
+++ b/tests/test_Layer.py
@@ -126,7 +126,7 @@ def test_parameters_raster_ok(mocked_put_data_str, mocked_utils_reproject_bbox,
         assert layer.geobbox == (0, 0, 100, 100)
         layer.write_descriptor("file:///home/ign/layers/")
         mocked_put_data_str.assert_called_once_with('{"title": "title", "abstract": "abstract", "keywords": ["RASTER", "layername"], "wmts": {"authorized": true}, "tms": {"authorized": true}, "bbox": {"south": 0, "west": 0, "north": 100, "east": 100}, "pyramids": [{"bottom_level": "10", "top_level": "10", "path": "file:///home/ign/pyramids/RGEALTI.json"}], "wms": {"authorized": true, "crs": ["CRS:84", "IGNF:WGS84G", "EPSG:3857", "EPSG:4258", "EPSG:4326"]}, "styles": ["normal"], "resampling": "nn"}', 'file:///home/ign/layers/layername.json')
-                                                     
+
 
     except Exception as exc:
-        assert False, f"Layer creation from parameters raises an exception: {exc}"
\ No newline at end of file
+        assert False, f"Layer creation from parameters raises an exception: {exc}"
diff --git a/tests/test_Pyramid.py b/tests/test_Pyramid.py
index 065e0b8..c1936dd 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_Pyramid.py
@@ -58,7 +58,7 @@ def test_raster_missing_raster_specifications(mocked_tms_class, mocked_get_data_
 @mock.patch('rok4.Pyramid.get_data_str', return_value='{"raster_specifications":{"channels":3,"nodata":"255,0,0","photometric":"rgb","interpolation":"bicubic"}, "format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"unknown"}], "tile_matrix_set": "PM"}')
 @mock.patch('rok4.Pyramid.TileMatrixSet')
 def test_wrong_level(mocked_tms_class, mocked_get_data_str):
-    
+
     tms_instance = MagicMock()
     tms_instance.get_level.return_value = None
     tms_instance.name = "PM"
@@ -66,7 +66,7 @@ def test_wrong_level(mocked_tms_class, mocked_get_data_str):
 
     with pytest.raises(Exception) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
-    
+
     mocked_tms_class.assert_called_once_with('PM')
     mocked_get_data_str.assert_called_once_with('file:///pyramid.json')
     tms_instance.get_level.assert_called_once_with('unknown')
@@ -165,7 +165,7 @@ def test_tile_read_raster(mocked_tms_class):
     tms_instance = MagicMock()
     tms_instance.name = "UTM20W84MART_1M_MNT"
     tms_instance.srs = "IGNF:UTM20W84MART"
-    
+
     tm_instance = MagicMock()
     tm_instance.id = "8"
     tm_instance.tile_size = (256,256)
@@ -192,7 +192,7 @@ def test_tile_read_vector(mocked_tms_class):
     tms_instance = MagicMock()
     tms_instance.name = "PM"
     tms_instance.srs = "EPSG:3857"
-    
+
     tm_instance = MagicMock()
     tm_instance.id = "4"
     tm_instance.tile_size = (256,256)
@@ -221,7 +221,7 @@ def test_list_read(mocked_tms_class):
     tms_instance = MagicMock()
     tms_instance.name = "PM"
     tms_instance.srs = "EPSG:3857"
-    
+
     tm_instance = MagicMock()
     tm_instance.id = "4"
     tm_instance.tile_size = (256,256)
@@ -252,4 +252,4 @@ def test_b36_path_decode():
 
 def test_b36_path_encode():
     assert b36_path_encode(4032, 18217, 2) == "3E/42/01.tif"
-    assert b36_path_encode(14, 18217, 1) == "0E02/E1.tif"
\ No newline at end of file
+    assert b36_path_encode(14, 18217, 1) == "0E02/E1.tif"
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index d7b2b24..6cc526e 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -128,7 +128,7 @@ def test_unsupported_mask_format(self, mocked_exists, mocked_gdal_open, mocked_i
         mocked_identifydriver.return_value = type('', (object,), {'ShortName': 'JPG'})
 
         with pytest.raises(Exception):
-            Raster.from_file(self.source_image_path)      
+            Raster.from_file(self.source_image_path)
 
         mocked_exists.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
         mocked_get_osgeo_path.assert_has_calls([ call(self.source_image_path), call(self.source_mask_path) ])
@@ -177,4 +177,3 @@ def test_image_and_mask(self):
         assert result.format == i_format
         assert result.dimensions == i_dimensions
         assert result.mask == i_mask
-    
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 34a5c37..69d2ece 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,4 @@ 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")
diff --git a/tests/test_TileMatrixSet.py b/tests/test_TileMatrixSet.py
index 4cf86f2..7f41688 100644
--- a/tests/test_TileMatrixSet.py
+++ b/tests/test_TileMatrixSet.py
@@ -127,4 +127,4 @@ def test_4326_conversions(mocked_get_data_str):
         assert tm.bbox_to_tiles((45,5,48,6)) == (269425,61166,270882,65535)
         assert tm.point_to_indices(45,5) == (269425, 65535, 199, 255)
     except Exception as exc:
-        assert False, f"'TileMatrixSet creation raises an exception: {exc}"
\ No newline at end of file
+        assert False, f"'TileMatrixSet creation raises an exception: {exc}"
diff --git a/tests/test_Utils.py b/tests/test_Utils.py
index 3ba87da..bc7acc9 100644
--- a/tests/test_Utils.py
+++ b/tests/test_Utils.py
@@ -256,7 +256,7 @@ def test_compute_format_bit_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, m
 def test_compute_format_uint8_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
-        
+
         band_number = random.randint(1, 4)
         mocked_datasource.RasterCount = band_number
         band_name = None
@@ -291,7 +291,7 @@ def test_compute_format_uint8_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize,
 def test_compute_format_float32_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
-        
+
         band_number = random.randint(1, 4)
         mocked_datasource.RasterCount = band_number
         band_name = None
@@ -345,7 +345,7 @@ def test_compute_format_unsupported_nok(mocked_GetDataTypeName, mocked_GetDataTy
 
         with pytest.raises(Exception):
             compute_format(mocked_datasource)
-        
+
         mocked_GetDataTypeName.assert_called()
         mocked_GetDataTypeSize.assert_called()
         mocked_GetColorInterpretationName.assert_called()
@@ -373,4 +373,3 @@ def test_compute_format_no_band_nok(mocked_GetDataTypeName, mocked_GetDataTypeSi
         mocked_Info.assert_not_called()
     except Exception as exc:
         assert False, f"Color format computation raises an exception: {exc}"
-
diff --git a/tests/test_Vector.py b/tests/test_Vector.py
index c7eb2e4..d9f22fc 100644
--- a/tests/test_Vector.py
+++ b/tests/test_Vector.py
@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 from rok4.Vector import *
 from rok4.Exceptions import *
 from rok4.Storage import disconnect_ceph_clients

From 8266c1765492f229f1ca0f15f67d9fdc46bd3a67 Mon Sep 17 00:00:00 2001
From: XavDmz <30922860+XavDmz@users.noreply.github.com>
Date: Thu, 11 May 2023 16:44:18 +0200
Subject: [PATCH 42/89] Update CONTRIBUTING.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Ajout d'une consigne dédiée au changelog.
---
 CONTRIBUTING.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 02aa3bf..c7542bb 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -9,3 +9,13 @@ Il s'agit principalement de lignes directrices, et non de règles. Faites preuve
 Nous utilisons les git hooks via [pre-commit](https://pre-commit.com/) pour appliquer et vérifier automatiquement certaines "règles". Veuillez l'installer avant de pousser un commit.
 
 Voir le fichier de configuration correspondant : `.pre-commit-config.yaml`.
+
+## CHANGELOG
+
+Pour éviter les conflits d'édition du changelog en cas de multiples contributions parallèles, n'éditez pas directement le fichier `CHANGELOG.md` sur votre branche de travail.
+A la place, indiquez en description ou commentaire de votre pull request, bien en évidence, le changelog qui concerne spécifiquement cette PR, avec le même formalisme que le fichier `CHANGELOG.md`.
+Le mainteneur qui validera la PR éditera alors ce fichier dans le même temps, avec deux objectifs :
+
+* la date de modification sera celle de la fusion de branches.
+* le contenu pourra tenir compte de toutes les modifications depuis la dernière release.
+

From 5cf0aa6488bf7358f6c89c997e81102024b9eb90 Mon Sep 17 00:00:00 2001
From: XavDmz <30922860+XavDmz@users.noreply.github.com>
Date: Thu, 11 May 2023 16:53:33 +0200
Subject: [PATCH 43/89] Update CONTRIBUTING.md

Ajout d'une description du formalisme attendu pour le changelog.
---
 CONTRIBUTING.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c7542bb..caa2d20 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -19,3 +19,32 @@ Le mainteneur qui validera la PR éditera alors ce fichier dans le même temps,
 * la date de modification sera celle de la fusion de branches.
 * le contenu pourra tenir compte de toutes les modifications depuis la dernière release.
 
+Le formalisme du changelog est le suivant, en markdown :
+
+```md
+### [Added]
+
+Liste de nouvelles fonctionnalités.
+
+### [Changed]
+
+Liste de fonctionnalités existantes modifiées.
+
+### [Deprecated]
+
+Liste de fonctionnalités dépréciées.
+
+### [Removed]
+
+Liste de foncitonnalités retirées.
+
+### [Fixed]
+
+Liste de corrections fonctionnelles.
+
+### [Security]
+
+Liste de corrections de sécurité.
+```
+
+Les parties vides, sans élément à lister, peuvent être ignorées.

From 75ad935477d1916ca552f93f0c6a9929e4471a2d Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 31 May 2023 15:54:36 +0200
Subject: [PATCH 44/89] Add pyupgrade git hook

---
 .pre-commit-config.yaml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index ddc5f9b..a451eb9 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -20,3 +20,10 @@ repos:
         args: [--pytest-test-first]
       - id: trailing-whitespace
         args: [--markdown-linebreak-ext=md]
+
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.3.1
+    hooks:
+      - id: pyupgrade
+        args:
+          - "--py38-plus"

From 87ca6420b188ccf8ff038b1bf8df8a475a01c1bb Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 31 May 2023 15:58:44 +0200
Subject: [PATCH 45/89] Apply pyupgrade git hook

---
 src/rok4/Pyramid.py | 2 +-
 src/rok4/Storage.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 75b433c..a72e800 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -736,7 +736,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
             roots = {}
             s3_cluster = self.storage_s3_cluster
 
-            with open(list_file, "r") as listin:
+            with open(list_file) as listin:
 
                 # Lecture des racines
                 for line in listin:
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index 3e22fd3..e28bd6b 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -806,7 +806,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
 
         try:
             target_s3_client["client"].put_object(
-                Body = f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode('utf-8'),
+                Body = f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode(),
                 Bucket = link_bucket,
                 Key = link_base_name
             )
@@ -818,7 +818,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
         ioctx = __get_ceph_ioctx(link_tray)
 
         try:
-            ioctx.write_full(link_base_name, f"{__OBJECT_SYMLINK_SIGNATURE}{target_path}".encode('utf-8'))
+            ioctx.write_full(link_base_name, f"{__OBJECT_SYMLINK_SIGNATURE}{target_path}".encode())
         except Exception as e:
             raise StorageError("CEPH", e)
 

From 9aa197cab9c4a96461e6ac28187159d7d6639137 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 31 May 2023 16:19:45 +0200
Subject: [PATCH 46/89] Add black config

---
 pyproject.toml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index a44b15f..a91d767 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -56,5 +56,9 @@ doc = [
 requires = ["setuptools>=61.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
+[tool.black]
+line-length = 100
+target-version = ['py38']
+
 [tool.setuptools.packages.find]
 where = ["src"]

From 03bede2377ebcd1b3de248cc9b7daaf4eb0c8d5a Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 31 May 2023 16:19:57 +0200
Subject: [PATCH 47/89] Add black git hook

---
 .pre-commit-config.yaml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index ddc5f9b..31a1cee 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -20,3 +20,8 @@ repos:
         args: [--pytest-test-first]
       - id: trailing-whitespace
         args: [--markdown-linebreak-ext=md]
+
+  - repo: https://github.com/psf/black
+    rev: 23.3.0
+    hooks:
+      - id: black

From a7c480a92f59c532115adc93997ed66cade817be Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Mon, 5 Jun 2023 17:00:36 +0200
Subject: [PATCH 48/89] Add black to dev dependencies

---
 pyproject.toml | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index a91d767..9f58bdd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -38,13 +38,19 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+doc = [
+  "pdoc3 >= 0.10.0"
+]
+
+dev = [
+  "black",
+  "pre-commit >3,<4"
+]
+
 test = [
   "pytest >= 7.1.2",
   "coverage >= 7.0.5"
 ]
-doc = [
-  "pdoc3 >= 0.10.0"
-]
 
 [project.urls]
 "Homepage" = "https://rok4.github.io/core-python"

From 5c690f50ad4fe582251e7e3b8a9faca44089803f Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Mon, 5 Jun 2023 17:00:58 +0200
Subject: [PATCH 49/89] Apply black to existing codebase

---
 src/rok4/Exceptions.py      |   3 +
 src/rok4/Layer.py           |  74 ++++----
 src/rok4/Pyramid.py         | 272 ++++++++++++++++----------
 src/rok4/Raster.py          |  40 ++--
 src/rok4/Storage.py         | 302 ++++++++++++++++-------------
 src/rok4/TileMatrixSet.py   |  54 ++++--
 src/rok4/Utils.py           |  66 ++++---
 src/rok4/Vector.py          |  84 ++++----
 tests/test_Layer.py         |  79 ++++----
 tests/test_Pyramid.py       | 163 ++++++++++------
 tests/test_Raster.py        | 216 ++++++++++++---------
 tests/test_Storage.py       | 370 +++++++++++++++++++++++++-----------
 tests/test_TileMatrixSet.py | 132 ++++++++++---
 tests/test_Utils.py         | 158 +++++++--------
 tests/test_Vector.py        |  94 ++++++---
 15 files changed, 1302 insertions(+), 805 deletions(-)

diff --git a/src/rok4/Exceptions.py b/src/rok4/Exceptions.py
index 92c75e3..c3b2b59 100644
--- a/src/rok4/Exceptions.py
+++ b/src/rok4/Exceptions.py
@@ -8,6 +8,7 @@ def __init__(self, path, missing):
         self.missing = missing
         super().__init__(f"Missing attribute {missing} in '{path}'")
 
+
 class MissingEnvironmentError(Exception):
     """
     Exception raised when a needed environment variable is not defined
@@ -17,6 +18,7 @@ def __init__(self, missing):
         self.missing = missing
         super().__init__(f"Missing environment variable {missing}")
 
+
 class StorageError(Exception):
     """
     Exception raised when an issue occured when using a storage
@@ -27,6 +29,7 @@ def __init__(self, type, issue):
         self.issue = issue
         super().__init__(f"Issue occured using a {type} storage : {issue}")
 
+
 class FormatError(Exception):
     """
     Exception raised when a format is expected but not respected
diff --git a/src/rok4/Layer.py b/src/rok4/Layer.py
index 3f421f3..316a9ca 100644
--- a/src/rok4/Layer.py
+++ b/src/rok4/Layer.py
@@ -17,6 +17,7 @@
 from rok4.Storage import *
 from rok4.Utils import *
 
+
 class Layer:
     """A data layer, raster or vector
 
@@ -34,7 +35,7 @@ class Layer:
     """
 
     @classmethod
-    def from_descriptor(cls, descriptor: str) -> 'Layer':
+    def from_descriptor(cls, descriptor: str) -> "Layer":
         """Create a layer from its descriptor
 
         Args:
@@ -58,7 +59,7 @@ def from_descriptor(cls, descriptor: str) -> 'Layer':
         layer = cls()
 
         storage_type, path, root, base_name = get_infos_from_path(descriptor)
-        layer.__name = base_name[:-5] # on supprime l'extension.json
+        layer.__name = base_name[:-5]  # on supprime l'extension.json
 
         try:
             # Attributs communs
@@ -71,7 +72,6 @@ def from_descriptor(cls, descriptor: str) -> 'Layer':
                 for k in data["keywords"]:
                     layer.__keywords.append(k)
 
-
             if layer.type == PyramidType.RASTER:
                 if "resampling" in data:
                     layer.__resampling = data["resampling"]
@@ -83,7 +83,12 @@ def from_descriptor(cls, descriptor: str) -> 'Layer':
 
             # Les bbox, native et géographique
             if "bbox" in data:
-                layer.__geobbox = (data["bbox"]["south"], data["bbox"]["west"], data["bbox"]["north"], data["bbox"]["east"])
+                layer.__geobbox = (
+                    data["bbox"]["south"],
+                    data["bbox"]["west"],
+                    data["bbox"]["north"],
+                    data["bbox"]["east"],
+                )
                 layer.__bbox = reproject_bbox(layer.__geobbox, "EPSG:4326", layer.__tms.srs, 5)
                 # On force l'emprise de la couche, on recalcule donc les tuiles limites correspondantes pour chaque niveau
                 for l in layer.__levels.values():
@@ -95,11 +100,10 @@ def from_descriptor(cls, descriptor: str) -> 'Layer':
         except KeyError as e:
             raise MissingAttributeError(descriptor, e)
 
-
         return layer
 
     @classmethod
-    def from_parameters(cls, pyramids: List[Dict[str, str]], name: str, **kwargs) -> 'Layer':
+    def from_parameters(cls, pyramids: List[Dict[str, str]], name: str, **kwargs) -> "Layer":
         """Create a default layer from parameters
 
         Args:
@@ -121,7 +125,9 @@ def from_parameters(cls, pyramids: List[Dict[str, str]], name: str, **kwargs) ->
 
         # Informations obligatoires
         if not re.match("^[A-Za-z0-9_-]*$", name):
-            raise Exception(f"Layer's name have to contain only letters, number, hyphen and underscore, to be URL and storage compliant ({name})")
+            raise Exception(
+                f"Layer's name have to contain only letters, number, hyphen and underscore, to be URL and storage compliant ({name})"
+            )
 
         layer.__name = name
         layer.__load_pyramids(pyramids)
@@ -156,7 +162,6 @@ def from_parameters(cls, pyramids: List[Dict[str, str]], name: str, **kwargs) ->
 
         return layer
 
-
     def __init__(self) -> None:
         self.__format = None
         self.__tms = None
@@ -181,7 +186,6 @@ def __load_pyramids(self, pyramids: List[Dict[str, str]]) -> None:
         ## Toutes les pyramides doivent avoir les même caractéristiques
         channels = None
         for p in pyramids:
-
             pyramid = Pyramid.from_descriptor(p["path"])
             bottom_level = p.get("bottom_level", None)
             top_level = p.get("top_level", None)
@@ -193,18 +197,24 @@ def __load_pyramids(self, pyramids: List[Dict[str, str]]) -> None:
                 top_level = pyramid.top_level.id
 
             if self.__format is not None and self.__format != pyramid.format:
-                raise Exception(f"Used pyramids have to own the same format : {self.__format} != {pyramid.format}")
+                raise Exception(
+                    f"Used pyramids have to own the same format : {self.__format} != {pyramid.format}"
+                )
             else:
                 self.__format = pyramid.format
 
             if self.__tms is not None and self.__tms.id != pyramid.tms.id:
-                raise Exception(f"Used pyramids have to use the same TMS : {self.__tms.id} != {pyramid.tms.id}")
+                raise Exception(
+                    f"Used pyramids have to use the same TMS : {self.__tms.id} != {pyramid.tms.id}"
+                )
             else:
                 self.__tms = pyramid.tms
 
             if self.type == PyramidType.RASTER:
                 if channels is not None and channels != pyramid.raster_specifications["channels"]:
-                    raise Exception(f"Used RASTER pyramids have to own the same number of channels : {channels} != {pyramid.raster_specifications['channels']}")
+                    raise Exception(
+                        f"Used RASTER pyramids have to own the same number of channels : {channels} != {pyramid.raster_specifications['channels']}"
+                    )
                 else:
                     channels = pyramid.raster_specifications["channels"]
                 self.__resampling = pyramid.raster_specifications["interpolation"]
@@ -215,11 +225,9 @@ def __load_pyramids(self, pyramids: List[Dict[str, str]]) -> None:
                     raise Exception(f"Level {l.id} is present in two used pyramids")
                 self.__levels[l.id] = l
 
-            self.__pyramids.append({
-                "pyramid": pyramid,
-                "bottom_level": bottom_level,
-                "top_level": top_level
-            })
+            self.__pyramids.append(
+                {"pyramid": pyramid, "bottom_level": bottom_level, "top_level": top_level}
+            )
 
         self.__best_level = sorted(self.__levels.values(), key=lambda l: l.resolution)[0]
 
@@ -237,38 +245,30 @@ def serializable(self) -> Dict:
             "title": self.__title,
             "abstract": self.__abstract,
             "keywords": self.__keywords,
-            "wmts": {
-                "authorized": True
-            },
-            "tms": {
-                "authorized": True
-            },
+            "wmts": {"authorized": True},
+            "tms": {"authorized": True},
             "bbox": {
                 "south": self.__geobbox[0],
                 "west": self.__geobbox[1],
                 "north": self.__geobbox[2],
-                "east": self.__geobbox[3]
+                "east": self.__geobbox[3],
             },
-            "pyramids": []
+            "pyramids": [],
         }
 
         for p in self.__pyramids:
-            serialization["pyramids"].append({
-                "bottom_level" : p["bottom_level"],
-                "top_level" : p["top_level"],
-                "path" : p["pyramid"].descriptor
-            })
+            serialization["pyramids"].append(
+                {
+                    "bottom_level": p["bottom_level"],
+                    "top_level": p["top_level"],
+                    "path": p["pyramid"].descriptor,
+                }
+            )
 
         if self.type == PyramidType.RASTER:
             serialization["wms"] = {
                 "authorized": True,
-                "crs": [
-                    "CRS:84",
-                    "IGNF:WGS84G",
-                    "EPSG:3857",
-                    "EPSG:4258",
-                    "EPSG:4326"
-                ]
+                "crs": ["CRS:84", "IGNF:WGS84G", "EPSG:3857", "EPSG:4258", "EPSG:4326"],
             }
 
             if self.__tms.srs.upper() not in serialization["wms"]["crs"]:
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 75b433c..a3d7144 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -22,21 +22,25 @@
 from rok4.Storage import *
 from rok4.Utils import *
 
+
 class PyramidType(Enum):
-    """ Pyramid's data type """
+    """Pyramid's data type"""
+
     RASTER = "RASTER"
     VECTOR = "VECTOR"
 
 
 class SlabType(Enum):
-    """ Slab's type """
-    DATA = "DATA" # Slab of data, raster or vector
-    MASK = "MASK" # Slab of mask, only for raster pyramid, image with one band : 0 is nodata, other values are data
+    """Slab's type"""
+
+    DATA = "DATA"  # Slab of data, raster or vector
+    MASK = "MASK"  # Slab of mask, only for raster pyramid, image with one band : 0 is nodata, other values are data
 
 
 ROK4_IMAGE_HEADER_SIZE = 2048
 """Slab's header size, 2048 bytes"""
 
+
 def b36_number_encode(number: int) -> str:
     """Convert base-10 number to base-36
 
@@ -49,9 +53,9 @@ def b36_number_encode(number: int) -> str:
         str: base-36 number
     """
 
-    alphabet='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
-    base36 = ''
+    base36 = ""
 
     if 0 <= number < len(alphabet):
         return alphabet[number]
@@ -62,6 +66,7 @@ def b36_number_encode(number: int) -> str:
 
     return base36
 
+
 def b36_number_decode(number: str) -> int:
     """Convert base-36 number to base-10
 
@@ -73,6 +78,7 @@ def b36_number_decode(number: str) -> int:
     """
     return int(number, 36)
 
+
 def b36_path_decode(path: str) -> Tuple[int, int]:
     """Get slab's column and row from a base-36 based path
 
@@ -83,8 +89,8 @@ def b36_path_decode(path: str) -> Tuple[int, int]:
         Tuple[int, int]: slab's column and row
     """
 
-    path = path.replace('/', '')
-    path = re.sub(r'(\.TIFF?)', "", path.upper())
+    path = path.replace("/", "")
+    path = re.sub(r"(\.TIFF?)", "", path.upper())
 
     b36_column = ""
     b36_row = ""
@@ -132,6 +138,7 @@ def b36_path_encode(column: int, row: int, slashs: int) -> str:
 
     return f"{b36_path}.tif"
 
+
 class Level:
     """A pyramid's level, raster or vector
 
@@ -143,7 +150,7 @@ class Level:
     """
 
     @classmethod
-    def from_descriptor(cls, data: Dict, pyramid: 'Pyramid') -> 'Level':
+    def from_descriptor(cls, data: Dict, pyramid: "Pyramid") -> "Level":
         """Create a pyramid's level from the pyramid's descriptor levels element
 
         Args:
@@ -165,27 +172,36 @@ def from_descriptor(cls, data: Dict, pyramid: 'Pyramid') -> 'Level':
         try:
             level.__id = data["id"]
             level.__tile_limits = data["tile_limits"]
-            level.__slab_size = (data["tiles_per_width"], data["tiles_per_height"],)
+            level.__slab_size = (
+                data["tiles_per_width"],
+                data["tiles_per_height"],
+            )
 
             # Informations sur le stockage : on les valide et stocke dans la pyramide
             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})")
+                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 "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")
+                    raise Exception(
+                        f"Pyramid {pyramid.__descriptor} does not define a mask format but level {level.__id} define mask storage informations"
+                    )
             else:
                 if pyramid.own_masks:
-                    raise Exception(f"Pyramid {pyramid.__descriptor} define a mask format but level {level.__id} does not define mask storage informations")
+                    raise Exception(
+                        f"Pyramid {pyramid.__descriptor} define a mask format but level {level.__id} does not define mask storage informations"
+                    )
 
         except KeyError as e:
             raise MissingAttributeError(pyramid.descriptor, f"levels[].{e}")
 
         # Attributs dans le cas d'un niveau vecteur
-        if level.__pyramid.type == PyramidType.VECTOR :
+        if level.__pyramid.type == PyramidType.VECTOR:
             try:
                 level.__tables = data["tables"]
 
@@ -195,7 +211,7 @@ def from_descriptor(cls, data: Dict, pyramid: 'Pyramid') -> 'Level':
         return level
 
     @classmethod
-    def from_other(cls, other: 'Level', pyramid: 'Pyramid') -> 'Level':
+    def from_other(cls, other: "Level", pyramid: "Pyramid") -> "Level":
         """Create a pyramid's level from another one
 
         Args:
@@ -219,7 +235,7 @@ def from_other(cls, other: 'Level', pyramid: 'Pyramid') -> 'Level':
         level.__slab_size = other.__slab_size
 
         # Attributs dans le cas d'un niveau vecteur
-        if level.__pyramid.type == PyramidType.VECTOR :
+        if level.__pyramid.type == PyramidType.VECTOR:
             level.__tables = other.__tables
 
         return level
@@ -227,7 +243,6 @@ def from_other(cls, other: 'Level', pyramid: 'Pyramid') -> 'Level':
     def __str__(self) -> str:
         return f"{self.__pyramid.type.name} pyramid's level '{self.__id}' ({self.__pyramid.storage_type.name} storage)"
 
-
     @property
     def serializable(self) -> Dict:
         """Get the dict version of the pyramid object, pyramid's descriptor compliant
@@ -239,7 +254,7 @@ def serializable(self) -> Dict:
             "id": self.__id,
             "tiles_per_width": self.__slab_size[0],
             "tiles_per_height": self.__slab_size[1],
-            "tile_limits": self.__tile_limits
+            "tile_limits": self.__tile_limits,
         }
 
         if self.__pyramid.type == PyramidType.VECTOR:
@@ -249,16 +264,18 @@ def serializable(self) -> Dict:
             serialization["storage"] = {
                 "type": "FILE",
                 "image_directory": f"{self.__pyramid.name}/DATA/{self.__id}",
-                "path_depth": self.__pyramid.storage_depth
+                "path_depth": self.__pyramid.storage_depth,
             }
             if self.__pyramid.own_masks:
-                serialization["storage"]["mask_directory"] = f"{self.__pyramid.name}/MASK/{self.__id}"
+                serialization["storage"][
+                    "mask_directory"
+                ] = f"{self.__pyramid.name}/MASK/{self.__id}"
 
         elif self.__pyramid.storage_type == StorageType.CEPH:
             serialization["storage"] = {
                 "type": "CEPH",
                 "image_prefix": f"{self.__pyramid.name}/DATA_{self.__id}",
-                "pool_name": self.__pyramid.storage_root
+                "pool_name": self.__pyramid.storage_root,
             }
             if self.__pyramid.own_masks:
                 serialization["storage"]["mask_prefix"] = f"{self.__pyramid.name}/MASK_{self.__id}"
@@ -267,7 +284,7 @@ def serializable(self) -> Dict:
             serialization["storage"] = {
                 "type": "S3",
                 "image_prefix": f"{self.__pyramid.name}/DATA_{self.__id}",
-                "bucket_name": self.__pyramid.storage_root
+                "bucket_name": self.__pyramid.storage_root,
             }
             if self.__pyramid.own_masks:
                 serialization["storage"]["mask_prefix"] = f"{self.__pyramid.name}/MASK_{self.__id}"
@@ -285,8 +302,12 @@ def bbox(self) -> Tuple[float, float, float, float]:
         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"])
-        max_bbox = self.__pyramid.tms.get_level(self.__id).tile_to_bbox(self.__tile_limits["max_col"], self.__tile_limits["min_row"])
+        min_bbox = self.__pyramid.tms.get_level(self.__id).tile_to_bbox(
+            self.__tile_limits["min_col"], self.__tile_limits["max_row"]
+        )
+        max_bbox = self.__pyramid.tms.get_level(self.__id).tile_to_bbox(
+            self.__tile_limits["max_col"], self.__tile_limits["min_row"]
+        )
 
         return (min_bbox[0], min_bbox[1], max_bbox[2], max_bbox[3])
 
@@ -316,7 +337,12 @@ def is_in_limits(self, column: int, row: int) -> bool:
         Returns:
             bool: True if tiles' limits contain the provided tile's indices
         """
-        return self.__tile_limits["min_row"] <= row and self.__tile_limits["max_row"] >= row and self.__tile_limits["min_col"] <= column and self.__tile_limits["max_col"] >= column
+        return (
+            self.__tile_limits["min_row"] <= row
+            and self.__tile_limits["max_row"] >= row
+            and self.__tile_limits["min_col"] <= column
+            and self.__tile_limits["max_col"] >= column
+        )
 
     def set_limits_from_bbox(self, bbox: Tuple[float, float, float, float]) -> None:
         """Set tile limits, based on provided bounding box
@@ -326,12 +352,14 @@ def set_limits_from_bbox(self, bbox: Tuple[float, float, float, float]) -> None:
 
         """
 
-        col_min, row_min, col_max, row_max = self.__pyramid.tms.get_level(self.__id).bbox_to_tiles(bbox)
+        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,
             "max_col": col_max,
             "max_row": row_max,
-            "min_col": col_min
+            "min_col": col_min,
         }
 
 
@@ -366,7 +394,7 @@ class Pyramid:
     """
 
     @classmethod
-    def from_descriptor(cls, descriptor: str) -> 'Pyramid':
+    def from_descriptor(cls, descriptor: str) -> "Pyramid":
         """Create a pyramid from its descriptor
 
         Args:
@@ -399,13 +427,16 @@ def from_descriptor(cls, descriptor: str) -> 'Pyramid':
         except JSONDecodeError as e:
             raise FormatError("JSON", descriptor, e)
 
-
         pyramid = cls()
 
-        pyramid.__storage["type"], path, pyramid.__storage["root"], base_name = get_infos_from_path(descriptor)
-        pyramid.__name = base_name[:-5] # on supprime l'extension.json
+        pyramid.__storage["type"], path, pyramid.__storage["root"], base_name = get_infos_from_path(
+            descriptor
+        )
+        pyramid.__name = base_name[:-5]  # on supprime l'extension.json
         pyramid.__descriptor = descriptor
-        pyramid.__list = get_path_from_infos(pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.list")
+        pyramid.__list = get_path_from_infos(
+            pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.list"
+        )
 
         try:
             # Attributs communs
@@ -413,7 +444,7 @@ def from_descriptor(cls, descriptor: str) -> 'Pyramid':
             pyramid.__format = data["format"]
 
             # Attributs d'une pyramide raster
-            if pyramid.type == PyramidType.RASTER :
+            if pyramid.type == PyramidType.RASTER:
                 pyramid.__raster_specifications = data["raster_specifications"]
 
                 if "mask_format" in data:
@@ -427,7 +458,9 @@ def from_descriptor(cls, descriptor: str) -> 'Pyramid':
                 pyramid.__levels[lev.id] = lev
 
                 if pyramid.__tms.get_level(lev.id) is None:
-                    raise Exception(f"Pyramid {descriptor} owns a level with the ID '{lev.id}', not defined in the TMS '{pyramid.tms.name}'")
+                    raise Exception(
+                        f"Pyramid {descriptor} owns a level with the ID '{lev.id}', not defined in the TMS '{pyramid.tms.name}'"
+                    )
 
         except KeyError as e:
             raise MissingAttributeError(descriptor, e)
@@ -438,7 +471,7 @@ def from_descriptor(cls, descriptor: str) -> 'Pyramid':
         return pyramid
 
     @classmethod
-    def from_other(cls, other: 'Pyramid', name: str, storage: Dict) -> 'Pyramid':
+    def from_other(cls, other: "Pyramid", name: str, storage: Dict) -> "Pyramid":
         """Create a pyramid from another one
 
         Args:
@@ -471,13 +504,17 @@ def from_other(cls, other: 'Pyramid', name: str, storage: Dict) -> 'Pyramid':
             pyramid.__storage = storage
             pyramid.__masks = other.__masks
 
-            pyramid.__descriptor = get_path_from_infos(pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.json")
-            pyramid.__list = get_path_from_infos(pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.list")
+            pyramid.__descriptor = get_path_from_infos(
+                pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.json"
+            )
+            pyramid.__list = get_path_from_infos(
+                pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.list"
+            )
             pyramid.__tms = other.__tms
             pyramid.__format = other.__format
 
             # Attributs d'une pyramide raster
-            if pyramid.type == PyramidType.RASTER :
+            if pyramid.type == PyramidType.RASTER:
                 if other.own_masks:
                     pyramid.__masks = True
                 else:
@@ -489,7 +526,6 @@ def from_other(cls, other: 'Pyramid', name: str, storage: Dict) -> 'Pyramid':
                 lev = Level.from_other(l, pyramid)
                 pyramid.__levels[lev.id] = lev
 
-
         except KeyError as e:
             raise MissingAttributeError(descriptor, e)
 
@@ -500,10 +536,7 @@ def __init__(self) -> None:
         self.__levels = {}
         self.__masks = None
 
-        self.__content = {
-            "loaded": False,
-            "cache": {}
-        }
+        self.__content = {"loaded": False, "cache": {}}
 
     def __str__(self) -> str:
         return f"{self.type.name} pyramid '{self.__name}' ({self.__storage['type'].name} storage)"
@@ -515,10 +548,7 @@ def serializable(self) -> Dict:
         Returns:
             Dict: descriptor structured object description
         """
-        serialization = {
-            "tile_matrix_set": self.__tms.name,
-            "format": self.__format
-        }
+        serialization = {"tile_matrix_set": self.__tms.name, "format": self.__format}
 
         serialization["levels"] = []
         sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
@@ -585,13 +615,14 @@ def storage_root(self) -> str:
         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
+        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:
         return self.__storage.get("depth", None)
 
-
     @property
     def storage_s3_cluster(self) -> str:
         """Get the pyramid's storage S3 cluster (host name)
@@ -607,7 +638,6 @@ def storage_s3_cluster(self) -> str:
         else:
             return None
 
-
     @storage_depth.setter
     def storage_depth(self, d: int) -> None:
         """Set the tree depth for a FILE storage
@@ -619,7 +649,9 @@ def storage_depth(self, d: int) -> None:
             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")
+            raise Exception(
+                f"Pyramid {pyramid.__descriptor} owns levels with different path depths"
+            )
         self.__storage["depth"] = d
 
     @property
@@ -632,7 +664,16 @@ def format(self) -> str:
 
     @property
     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"]:
+        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"]:
             return "jpg"
@@ -641,10 +682,12 @@ def tile_extension(self) -> str:
         elif self.__format == "TIFF_PBF_MVT":
             return "pbf"
         else:
-            raise Exception(f"Unknown pyramid's format ({self.__format}), cannot return the tile extension")
+            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:
@@ -653,7 +696,7 @@ def bottom_level(self) -> 'Level':
         return sorted(self.__levels.values(), key=lambda l: l.resolution)[0]
 
     @property
-    def top_level(self) -> 'Level':
+    def top_level(self) -> "Level":
         """Get the low resolution level in the pyramid
 
         Returns:
@@ -686,7 +729,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
@@ -726,9 +769,8 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
             for slab, infos in self.__content["cache"].items():
                 yield slab, infos
         else:
-
             # Copie de la liste dans un fichier temporaire (cette liste peut être un objet)
-            list_obj = tempfile.NamedTemporaryFile(mode='r', delete=False)
+            list_obj = tempfile.NamedTemporaryFile(mode="r", delete=False)
             list_file = list_obj.name
             copy(self.__list, f"file://{list_file}")
             list_obj.close()
@@ -737,7 +779,6 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
             s3_cluster = self.storage_s3_cluster
 
             with open(list_file, "r") as listin:
-
                 # Lecture des racines
                 for line in listin:
                     line = line.rstrip()
@@ -769,16 +810,16 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]:
                     slab_type, level, column, row = self.get_infos_from_slab_path(slab_path)
                     infos = {
                         "root": roots[root_id],
-                        "link": root_id != '0',
+                        "link": root_id != "0",
                         "slab": slab_path,
-                        "md5": slab_md5
+                        "md5": slab_md5,
                     }
 
-                    yield ((slab_type,level,column,row), infos)
+                    yield ((slab_type, level, column, row), infos)
 
             remove(f"file://{list_file}")
 
-    def get_level(self, level_id: str) -> 'Level':
+    def get_level(self, level_id: str) -> "Level":
         """Get one level according to its identifier
 
         Args:
@@ -790,7 +831,6 @@ def get_level(self, level_id: str) -> 'Level':
 
         return self.__levels.get(level_id, None)
 
-
     def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
         """Get sorted levels in the provided range from bottom to top
 
@@ -839,7 +879,9 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
             begin = True
         else:
             if self.get_level(bottom_id) is None:
-                raise Exception(f"Pyramid {self.name} does not contain the provided bottom level {bottom_id}")
+                raise Exception(
+                    f"Pyramid {self.name} does not contain the provided bottom level {bottom_id}"
+                )
 
         if top_id is not None and self.get_level(top_id) is None:
             raise Exception(f"Pyramid {self.name} does not contain the provided top level {top_id}")
@@ -863,13 +905,14 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
             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}")
+            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)
-        """
+        """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)
 
@@ -911,9 +954,9 @@ def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
 
             # Le partie du chemin qui contient la colonne et ligne de la dalle est à la fin, en fonction de la profondeur choisie
             # depth = 2 -> on doit utiliser les 3 dernières parties pour la conversion
-            column, row = b36_path_decode('/'.join(parts[-(self.__storage["depth"]+1):]))
-            level = parts[-(self.__storage["depth"]+2)]
-            raw_slab_type = parts[-(self.__storage["depth"]+3)]
+            column, row = b36_path_decode("/".join(parts[-(self.__storage["depth"] + 1) :]))
+            level = parts[-(self.__storage["depth"] + 2)]
+            raw_slab_type = parts[-(self.__storage["depth"] + 3)]
 
             # Pour être retro compatible avec l'ancien nommage
             if raw_slab_type == "IMAGE":
@@ -923,7 +966,7 @@ def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
 
             return slab_type, level, column, row
         else:
-            parts = re.split(r'[/_]', path)
+            parts = re.split(r"[/_]", path)
             column = parts[-2]
             row = parts[-1]
             level = parts[-3]
@@ -939,7 +982,9 @@ def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
 
             return slab_type, level, int(column), int(row)
 
-    def get_slab_path_from_infos(self, slab_type: SlabType, level: str, column: int, row: int, full: bool = True) -> str:
+    def get_slab_path_from_infos(
+        self, slab_type: SlabType, level: str, column: int, row: int, full: bool = True
+    ) -> str:
         """Get slab's storage path from the indices
 
         Args:
@@ -953,16 +998,19 @@ def get_slab_path_from_infos(self, slab_type: SlabType, level: str, column: int,
             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"]))
+            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 )
+            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
 
@@ -1041,21 +1089,27 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
         # puis sont stockés les offsets (chacun sur 4 octets)
         # puis les tailles (chacune sur 4 octets)
         try:
-            binary_index = get_data_binary(slab_path, (ROK4_IMAGE_HEADER_SIZE, 2 * 4 * level_object.slab_width * level_object.slab_height))
+            binary_index = get_data_binary(
+                slab_path,
+                (
+                    ROK4_IMAGE_HEADER_SIZE,
+                    2 * 4 * level_object.slab_width * level_object.slab_height,
+                ),
+            )
         except FileNotFoundError as e:
             # L'absence de la dalle est gérée comme simplement une absence de données
             return None
 
         offsets = numpy.frombuffer(
             binary_index,
-            dtype = numpy.dtype('uint32'),
-            count = level_object.slab_width * level_object.slab_height
+            dtype=numpy.dtype("uint32"),
+            count=level_object.slab_width * level_object.slab_height,
         )
         sizes = numpy.frombuffer(
             binary_index,
-            dtype = numpy.dtype('uint32'),
-            offset = 4 * level_object.slab_width * level_object.slab_height,
-            count = level_object.slab_width * level_object.slab_height
+            dtype=numpy.dtype("uint32"),
+            offset=4 * level_object.slab_width * level_object.slab_height,
+            count=level_object.slab_width * level_object.slab_height,
         )
 
         if sizes[tile_index] == 0:
@@ -1118,9 +1172,7 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
 
         level_object = self.get_level(level)
 
-
         if self.__format == "TIFF_JPG_UINT8" or self.__format == "TIFF_JPG90_UINT8":
-
             try:
                 img = Image.open(io.BytesIO(binary_tile))
             except Exception as e:
@@ -1129,11 +1181,12 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
             data = numpy.asarray(img)
 
         elif self.__format == "TIFF_RAW_UINT8":
-            data = numpy.frombuffer(
-                binary_tile,
-                dtype = numpy.dtype('uint8')
+            data = numpy.frombuffer(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:
@@ -1145,32 +1198,35 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
 
         elif self.__format == "TIFF_ZIP_UINT8":
             try:
-                data = numpy.frombuffer(
-                    zlib.decompress( binary_tile ),
-                    dtype = numpy.dtype('uint8')
-                )
+                data = numpy.frombuffer(zlib.decompress(binary_tile), dtype=numpy.dtype("uint8"))
             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:
-                data = numpy.frombuffer(
-                    zlib.decompress( binary_tile ),
-                    dtype = numpy.dtype('float32')
-                )
+                data = numpy.frombuffer(zlib.decompress(binary_tile), dtype=numpy.dtype("float32"))
             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 = 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}")
@@ -1238,7 +1294,9 @@ def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
 
         return data
 
-    def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> Tuple[str, int, int, int, int]:
+    def get_tile_indices(
+        self, x: float, y: float, level: str = None, **kwargs
+    ) -> Tuple[str, int, int, int, int]:
         """Get pyramid's tile and pixel indices from point's coordinates
 
         Used coordinates system have to be the pyramid one. If EPSG:4326, x is latitude and y longitude.
@@ -1283,8 +1341,12 @@ def get_tile_indices(self, x: float, y: float, level: str = None, **kwargs) -> T
         if level_object is None:
             raise Exception(f"Cannot found the level to calculate indices")
 
-        if "srs" in kwargs and kwargs["srs"] is not None and kwargs["srs"].upper() != self.__tms.srs.upper():
+        if (
+            "srs" in kwargs
+            and kwargs["srs"] is not None
+            and kwargs["srs"].upper() != self.__tms.srs.upper()
+        ):
             sr = srs_to_spatialreference(kwargs["srs"])
-            x, y = reproject_point((x, y), sr, self.__tms.sr )
+            x, y = reproject_point((x, y), sr, self.__tms.sr)
 
         return (level_object.id,) + level_object.tile_matrix.point_to_indices(x, y)
diff --git a/src/rok4/Raster.py b/src/rok4/Raster.py
index 1d7d6b5..640f4bf 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -15,12 +15,13 @@
 from osgeo import ogr, gdal
 
 from rok4.Storage import exists, get_osgeo_path, put_data_str
-from rok4.Utils import ColorFormat, compute_bbox,compute_format
+from rok4.Utils import ColorFormat, compute_bbox, compute_format
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 gdal.UseExceptions()
 
+
 class Raster:
     """A structure describing raster data
 
@@ -91,9 +92,11 @@ def from_file(cls, path: str) -> "Raster":
         if exists(mask_path):
             work_mask_path = get_osgeo_path(mask_path)
             mask_driver = gdal.IdentifyDriver(work_mask_path).ShortName
-            if 'GTiff' != mask_driver:
-                message = (f"Mask file '{mask_path}' is not a TIFF image."
-                           + f" (GDAL driver : '{mask_driver}'")
+            if "GTiff" != mask_driver:
+                message = (
+                    f"Mask file '{mask_path}' is not a TIFF image."
+                    + f" (GDAL driver : '{mask_driver}'"
+                )
                 raise Exception(message)
             self.mask = mask_path
         else:
@@ -108,8 +111,14 @@ def from_file(cls, path: str) -> "Raster":
 
     @classmethod
     def from_parameters(
-            cls, path: str, bands: int, bbox: Tuple[float, float, float, float],
-            dimensions: Tuple[int, int], format: ColorFormat, mask: str = None) -> "Raster":
+        cls,
+        path: str,
+        bands: int,
+        bbox: Tuple[float, float, float, float],
+        dimensions: Tuple[int, int],
+        format: ColorFormat,
+        mask: str = None,
+    ) -> "Raster":
         """Creates a Raster object from parameters
 
         Args:
@@ -297,13 +306,13 @@ def from_descriptor(cls, path: str) -> "RasterSet":
             parameters = copy.deepcopy(raster_dict)
             parameters["bbox"] = tuple(raster_dict["bbox"])
             parameters["dimensions"] = tuple(raster_dict["dimensions"])
-            parameters["format"] = ColorFormat[ raster_dict["format"] ]
+            parameters["format"] = ColorFormat[raster_dict["format"]]
             self.raster_list.append(Raster.from_parameters(**parameters))
         self.bbox = tuple(serialization["bbox"])
         self.colors = []
         for color_dict in serialization["colors"]:
             color_item = copy.deepcopy(color_dict)
-            color_item["format"] = ColorFormat[ color_dict["format"] ]
+            color_item["format"] = ColorFormat[color_dict["format"]]
             self.colors.append(color_item)
         return self
 
@@ -314,17 +323,9 @@ def serializable(self) -> Dict:
         Returns:
             Dict: descriptor structured object description
         """
-        serialization = {
-            "bbox": list(self.bbox),
-            "srs": self.srs,
-            "colors": [],
-            "raster_list" : []
-        }
+        serialization = {"bbox": list(self.bbox), "srs": self.srs, "colors": [], "raster_list": []}
         for color in self.colors:
-            color_serial = {
-                "bands": color["bands"],
-                "format": color["format"].name
-            }
+            color_serial = {"bands": color["bands"], "format": color["format"].name}
             serialization["colors"].append(color_serial)
         for raster in self.raster_list:
             raster_dict = {
@@ -332,7 +333,7 @@ def serializable(self) -> Dict:
                 "dimensions": list(raster.dimensions),
                 "bbox": list(raster.bbox),
                 "bands": raster.bands,
-                "format": raster.format.name
+                "format": raster.format.name,
             }
             if raster.mask is not None:
                 raster_dict["mask"] = raster.mask
@@ -352,4 +353,3 @@ def write_descriptor(self, path: str = None) -> None:
             print(content)
         else:
             put_data_str(content, path)
-
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index 3e22fd3..11d59f1 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -44,14 +44,18 @@
 
 from rok4.Exceptions import *
 
+
 class StorageType(Enum):
     FILE = "file://"
     S3 = "s3://"
     CEPH = "ceph://"
 
+
 __S3_CLIENTS = {}
 __S3_DEFAULT_CLIENT = None
-def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',str]], str, str]:
+
+
+def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", str]], str, str]:
     """Get the S3 client
 
     Create it if not already done
@@ -76,10 +80,12 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',st
             urls = os.environ["ROK4_S3_URL"].split(",")
 
             if len(keys) != len(secret_keys) or len(keys) != len(urls):
-                raise StorageError("S3", "S3 informations in environment variables are inconsistent : same number of element in each list is required")
+                raise StorageError(
+                    "S3",
+                    "S3 informations in environment variables are inconsistent : same number of element in each list is required",
+                )
 
             for i in range(len(keys)):
-
                 h = re.sub("https?://", "", urls[i])
 
                 if h in __S3_CLIENTS:
@@ -87,15 +93,15 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',st
 
                 __S3_CLIENTS[h] = {
                     "client": boto3.client(
-                        's3',
-                        aws_access_key_id = keys[i],
-                        aws_secret_access_key = secret_keys[i],
-                        endpoint_url = urls[i]
+                        "s3",
+                        aws_access_key_id=keys[i],
+                        aws_secret_access_key=secret_keys[i],
+                        endpoint_url=urls[i],
                     ),
                     "key": keys[i],
                     "secret_key": secret_keys[i],
                     "url": urls[i],
-                    "host": h
+                    "host": h,
                 }
 
                 if i == 0:
@@ -107,7 +113,6 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',st
         except Exception as e:
             raise StorageError("S3", e)
 
-
     try:
         host = bucket_name.split("@")[1]
     except IndexError:
@@ -120,16 +125,19 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union['boto3.client',st
 
     return __S3_CLIENTS[host], bucket_name
 
+
 def disconnect_s3_clients() -> None:
-    """Clean S3 clients
-    """
+    """Clean S3 clients"""
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
     __S3_CLIENTS = {}
     __S3_DEFAULT_CLIENT = None
 
+
 __CEPH_CLIENT = None
 __CEPH_IOCTXS = {}
-def __get_ceph_ioctx(pool: str) -> 'rados.Ioctx':
+
+
+def __get_ceph_ioctx(pool: str) -> "rados.Ioctx":
     """Get the CEPH IO context
 
     Create it (client and context) if not already done
@@ -149,9 +157,9 @@ def __get_ceph_ioctx(pool: str) -> 'rados.Ioctx':
     if __CEPH_CLIENT is None:
         try:
             __CEPH_CLIENT = rados.Rados(
-                conffile = os.environ["ROK4_CEPH_CONFFILE"],
-                clustername = os.environ["ROK4_CEPH_CLUSTERNAME"],
-                name = os.environ["ROK4_CEPH_USERNAME"]
+                conffile=os.environ["ROK4_CEPH_CONFFILE"],
+                clustername=os.environ["ROK4_CEPH_CLUSTERNAME"],
+                name=os.environ["ROK4_CEPH_USERNAME"],
             )
 
             __CEPH_CLIENT.connect()
@@ -169,15 +177,17 @@ def __get_ceph_ioctx(pool: str) -> 'rados.Ioctx':
 
     return __CEPH_IOCTXS[pool]
 
+
 def disconnect_ceph_clients() -> None:
-    """Clean CEPH clients
-    """
+    """Clean CEPH clients"""
     global __CEPH_CLIENT, __CEPH_IOCTXS
     __CEPH_CLIENT = None
     __CEPH_IOCTXS = {}
 
+
 __OBJECT_SYMLINK_SIGNATURE = "SYMLINK#"
 
+
 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)
 
@@ -231,14 +241,15 @@ def hash_file(path: str) -> str:
 
     checker = hashlib.md5()
 
-    with open(path,'rb') as file:
+    with open(path, "rb") as file:
         chunk = 0
-        while chunk != b'':
+        while chunk != b"":
             chunk = file.read(65536)
             checker.update(chunk)
 
     return checker.hexdigest()
 
+
 def get_data_str(path: str) -> str:
     """Load full data into a string
 
@@ -254,7 +265,7 @@ def get_data_str(path: str) -> str:
         str: Data content
     """
 
-    return get_data_binary(path).decode('utf-8')
+    return get_data_binary(path).decode("utf-8")
 
 
 def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
@@ -273,27 +284,34 @@ 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:
             if range is None:
-                data = s3_client["client"].get_object(
-                    Bucket=bucket_name,
-                    Key=base_name,
-                )['Body'].read()
+                data = (
+                    s3_client["client"]
+                    .get_object(
+                        Bucket=bucket_name,
+                        Key=base_name,
+                    )["Body"]
+                    .read()
+                )
             else:
-                data = s3_client["client"].get_object(
-                    Bucket=bucket_name,
-                    Key=base_name,
-                    Range=f"bytes={range[0]}-{range[0] + range[1] - 1}"
-                )['Body'].read()
+                data = (
+                    s3_client["client"]
+                    .get_object(
+                        Bucket=bucket_name,
+                        Key=base_name,
+                        Range=f"bytes={range[0]}-{range[0] + range[1] - 1}",
+                    )["Body"]
+                    .read()
+                )
 
         except botocore.exceptions.ClientError as e:
-            if e.response['Error']['Code'] == "404":
+            if e.response["Error"]["Code"] == "404":
                 raise FileNotFoundError(f"{storage_type.value}{path}")
             else:
                 raise StorageError("S3", e)
@@ -302,7 +320,6 @@ 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:
@@ -319,9 +336,8 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             raise StorageError("CEPH", e)
 
     elif storage_type == StorageType.FILE:
-
         try:
-            f = open(path, 'rb')
+            f = open(path, "rb")
             if range is None:
                 data = f.read()
             else:
@@ -341,6 +357,7 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
 
     return data
 
+
 def put_data_str(data: str, path: str) -> None:
     """Store string data into a file or an object
 
@@ -355,34 +372,29 @@ def put_data_str(data: str, path: str) -> None:
         StorageError: Storage write issue
     """
 
-    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:
             s3_client["client"].put_object(
-                Body = data.encode('utf-8'),
-                Bucket = bucket_name,
-                Key = base_name
+                Body=data.encode("utf-8"), Bucket=bucket_name, Key=base_name
             )
         except Exception as e:
             raise StorageError("S3", e)
 
     elif storage_type == StorageType.CEPH:
-
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
-            ioctx.write_full(base_name, data.encode('utf-8'))
+            ioctx.write_full(base_name, data.encode("utf-8"))
         except Exception as e:
             raise StorageError("CEPH", e)
 
     elif storage_type == StorageType.FILE:
-
         try:
-            f = open(path, 'w')
+            f = open(path, "w")
             f.write(data)
             f.close()
         except Exception as e:
@@ -406,20 +418,20 @@ def get_size(path: str) -> int:
         int: file/object size, in bytes
     """
 
-    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:
-            size = s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)["ContentLength"]
+            size = s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)[
+                "ContentLength"
+            ]
             return int(size)
         except Exception as e:
             raise StorageError("S3", e)
 
     elif storage_type == StorageType.CEPH:
-
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -429,7 +441,6 @@ def get_size(path: str) -> int:
             raise StorageError("CEPH", e)
 
     elif storage_type == StorageType.FILE:
-
         try:
             file_stats = os.stat(path)
             return file_stats.st_size
@@ -454,23 +465,21 @@ def exists(path: str) -> bool:
         bool: file/object existing status
     """
 
-    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:
             s3_client["client"].head_object(Bucket=bucket_name, Key=base_name)
             return True
         except botocore.exceptions.ClientError as e:
-            if e.response['Error']['Code'] == "404":
+            if e.response["Error"]["Code"] == "404":
                 return False
             else:
                 raise StorageError("S3", e)
 
     elif storage_type == StorageType.CEPH:
-
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -482,12 +491,12 @@ def exists(path: str) -> bool:
             raise StorageError("CEPH", e)
 
     elif storage_type == StorageType.FILE:
-
         return os.path.exists(path)
 
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to test if exists")
 
+
 def remove(path: str) -> None:
     """Remove the file/object
 
@@ -498,22 +507,17 @@ def remove(path: str) -> None:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage removal issue
     """
-    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:
-            s3_client["client"].delete_object(
-                Bucket=bucket_name,
-                Key=base_name
-            )
+            s3_client["client"].delete_object(Bucket=bucket_name, Key=base_name)
         except Exception as e:
             raise StorageError("S3", e)
 
     elif storage_type == StorageType.CEPH:
-
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -524,7 +528,6 @@ def remove(path: str) -> None:
             raise StorageError("CEPH", e)
 
     elif storage_type == StorageType.FILE:
-
         try:
             os.remove(path)
         except FileNotFoundError as e:
@@ -535,6 +538,7 @@ def remove(path: str) -> None:
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to remove things")
 
+
 def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
     """Copy a file or object to a file or object place. If MD5 sum is provided, it is compared to sum after the copy.
 
@@ -548,28 +552,29 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         MissingEnvironmentError: Missing object storage informations
     """
 
-    from_type, from_path, from_tray, from_base_name  = get_infos_from_path(from_path)
-    to_type, to_path, to_tray, to_base_name  = get_infos_from_path(to_path)
+    from_type, from_path, from_tray, from_base_name = get_infos_from_path(from_path)
+    to_type, to_path, to_tray, to_base_name = get_infos_from_path(to_path)
 
     # Réalisation de la copie, selon les types de stockage
-    if from_type == StorageType.FILE and to_type == StorageType.FILE :
-
+    if from_type == StorageType.FILE and to_type == StorageType.FILE:
         try:
             if to_tray != "":
                 os.makedirs(to_tray, exist_ok=True)
 
             copyfile(from_path, to_path)
 
-            if from_md5 is not None :
+            if from_md5 is not None:
                 to_md5 = hash_file(to_path)
                 if to_md5 != from_md5:
-                    raise StorageError(f"FILE", f"Invalid MD5 sum control for copy file {from_path} to {to_path} : {from_md5} != {to_md5}")
+                    raise StorageError(
+                        f"FILE",
+                        f"Invalid MD5 sum control for copy file {from_path} to {to_path} : {from_md5} != {to_md5}",
+                    )
 
         except Exception as e:
             raise StorageError(f"FILE", f"Cannot copy file {from_path} to {to_path} : {e}")
 
-    elif from_type == StorageType.S3 and to_type == StorageType.FILE :
-
+    elif from_type == StorageType.S3 and to_type == StorageType.FILE:
         s3_client, from_bucket = __get_s3_client(from_tray)
 
         try:
@@ -578,68 +583,80 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
             s3_client["client"].download_file(from_bucket, from_base_name, to_path)
 
-            if from_md5 is not None :
+            if from_md5 is not None:
                 to_md5 = hash_file(to_path)
                 if to_md5 != from_md5:
-                    raise StorageError("S3 and FILE", f"Invalid MD5 sum control for copy S3 object {from_path} to file {to_path} : {from_md5} != {to_md5}")
+                    raise StorageError(
+                        "S3 and FILE",
+                        f"Invalid MD5 sum control for copy S3 object {from_path} to file {to_path} : {from_md5} != {to_md5}",
+                    )
 
         except Exception as e:
-            raise StorageError(f"S3 and FILE", f"Cannot copy S3 object {from_path} to file {to_path} : {e}")
-
-    elif from_type == StorageType.FILE and to_type == StorageType.S3 :
+            raise StorageError(
+                f"S3 and FILE", f"Cannot copy S3 object {from_path} to file {to_path} : {e}"
+            )
 
+    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)
 
-            if from_md5 is not None :
-                to_md5 = s3_client["client"].head_object(Bucket=to_bucket, Key=to_base_name)["ETag"].strip('"')
+            if from_md5 is not None:
+                to_md5 = (
+                    s3_client["client"]
+                    .head_object(Bucket=to_bucket, Key=to_base_name)["ETag"]
+                    .strip('"')
+                )
                 if to_md5 != from_md5:
-                    raise StorageError(f"FILE and S3", f"Invalid MD5 sum control for copy file {from_path} to S3 object {to_path} : {from_md5} != {to_md5}")
+                    raise StorageError(
+                        f"FILE and S3",
+                        f"Invalid MD5 sum control for copy file {from_path} to S3 object {to_path} : {from_md5} != {to_md5}",
+                    )
         except Exception as e:
-            raise StorageError(f"FILE and S3", f"Cannot copy file {from_path} to S3 object {to_path} : {e}")
-
-    elif from_type == StorageType.S3 and to_type == StorageType.S3 :
+            raise StorageError(
+                f"FILE and S3", f"Cannot copy file {from_path} to S3 object {to_path} : {e}"
+            )
 
+    elif from_type == StorageType.S3 and to_type == StorageType.S3:
         from_s3_client, from_bucket = __get_s3_client(from_tray)
         to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
             if to_s3_client["host"] == from_s3_client["host"]:
                 to_s3_client["client"].copy(
-                    {
-                        'Bucket': from_bucket,
-                        'Key': from_base_name
-                    },
-                    to_bucket, to_base_name
+                    {"Bucket": from_bucket, "Key": from_base_name}, to_bucket, to_base_name
                 )
             else:
                 with tempfile.NamedTemporaryFile("w+b") as f:
                     from_s3_client["client"].download_fileobj(from_bucket, from_base_name, f)
                     to_s3_client["client"].upload_file(f.name, to_bucket, to_base_name)
 
-            if from_md5 is not None :
-                to_md5 = to_s3_client["client"].head_object(Bucket=to_bucket, Key=to_base_name)["ETag"].strip('"')
+            if from_md5 is not None:
+                to_md5 = (
+                    to_s3_client["client"]
+                    .head_object(Bucket=to_bucket, Key=to_base_name)["ETag"]
+                    .strip('"')
+                )
                 if to_md5 != from_md5:
-                    raise StorageError(f"S3", f"Invalid MD5 sum control for copy S3 object {from_path} to {to_path} : {from_md5} != {to_md5}")
+                    raise StorageError(
+                        f"S3",
+                        f"Invalid MD5 sum control for copy S3 object {from_path} to {to_path} : {from_md5} != {to_md5}",
+                    )
 
         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 :
-
+    elif from_type == StorageType.CEPH and to_type == StorageType.FILE:
         ioctx = __get_ceph_ioctx(from_tray)
 
         if from_md5 is not None:
             checker = hashlib.md5()
 
         try:
-
             if to_tray != "":
                 os.makedirs(to_tray, exist_ok=True)
-            f = open(to_path, 'wb')
+            f = open(to_path, "wb")
 
             offset = 0
             size = 0
@@ -659,27 +676,29 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             f.close()
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
-                raise StorageError(f"CEPH and FILE", f"Invalid MD5 sum control for copy CEPH object {from_path} to file {to_path} : {from_md5} != {checker.hexdigest()}")
+                raise StorageError(
+                    f"CEPH and FILE",
+                    f"Invalid MD5 sum control for copy CEPH object {from_path} to file {to_path} : {from_md5} != {checker.hexdigest()}",
+                )
 
         except Exception as e:
-            raise StorageError(f"CEPH and FILE", f"Cannot copy CEPH object {from_path} to file {to_path} : {e}")
-
-
-    elif from_type == StorageType.FILE and to_type == StorageType.CEPH :
+            raise StorageError(
+                f"CEPH and FILE", f"Cannot copy CEPH object {from_path} to file {to_path} : {e}"
+            )
 
+    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()
 
         try:
-            f = open(from_path, 'rb')
+            f = open(from_path, "rb")
 
             offset = 0
             size = 0
 
             while True:
-
                 chunk = f.read(65536)
                 size = len(chunk)
                 ioctx.write(to_base_name, chunk, offset)
@@ -694,14 +713,17 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             f.close()
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
-                raise StorageError(f"FILE and CEPH", f"Invalid MD5 sum control for copy file {from_path} to CEPH object {to_path} : {from_md5} != {checker.hexdigest()}")
+                raise StorageError(
+                    f"FILE and CEPH",
+                    f"Invalid MD5 sum control for copy file {from_path} to CEPH object {to_path} : {from_md5} != {checker.hexdigest()}",
+                )
 
         except Exception as e:
-            raise StorageError(f"FILE and CEPH", f"Cannot copy file {from_path} to CEPH object {to_path} : {e}")
-
-
-    elif from_type == StorageType.CEPH and to_type == StorageType.CEPH :
+            raise StorageError(
+                f"FILE and CEPH", f"Cannot copy file {from_path} to CEPH object {to_path} : {e}"
+            )
 
+    elif from_type == StorageType.CEPH and to_type == StorageType.CEPH:
         from_ioctx = __get_ceph_ioctx(from_tray)
         to_ioctx = __get_ceph_ioctx(to_tray)
 
@@ -709,7 +731,6 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             checker = hashlib.md5()
 
         try:
-
             offset = 0
             size = 0
 
@@ -726,13 +747,15 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                     break
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
-                raise StorageError(f"FILE and CEPH", f"Invalid MD5 sum control for copy CEPH object {from_path} to {to_path} : {from_md5} != {checker.hexdigest()}")
+                raise StorageError(
+                    f"FILE and CEPH",
+                    f"Invalid MD5 sum control for copy CEPH object {from_path} to {to_path} : {from_md5} != {checker.hexdigest()}",
+                )
 
         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 :
-
+    elif from_type == StorageType.CEPH and to_type == StorageType.S3:
         from_ioctx = __get_ceph_ioctx(from_tray)
 
         s3_client, to_bucket = __get_s3_client(to_tray)
@@ -744,7 +767,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             offset = 0
             size = 0
 
-            with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
+            with tempfile.NamedTemporaryFile("w+b", delete=False) as f:
                 name_tmp = f.name
                 while True:
                     chunk = from_ioctx.read(from_base_name, 65536, offset)
@@ -763,14 +786,21 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             os.remove(name_tmp)
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
-                raise StorageError(f"CEPH and S3", f"Invalid MD5 sum control for copy CEPH object {from_path} to S3 object {to_path} : {from_md5} != {checker.hexdigest()}")
+                raise StorageError(
+                    f"CEPH and S3",
+                    f"Invalid MD5 sum control for copy CEPH object {from_path} to S3 object {to_path} : {from_md5} != {checker.hexdigest()}",
+                )
 
         except Exception as e:
-            raise StorageError(f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}")
+            raise StorageError(
+                f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}"
+            )
 
     else:
-        raise StorageError(f"{from_type.name} and {to_type.name}", f"Cannot copy from {from_type.name} to {to_type.name}")
-
+        raise StorageError(
+            f"{from_type.name} and {to_type.name}",
+            f"Cannot copy from {from_type.name} to {to_type.name}",
+        )
 
 
 def link(target_path: str, link_path: str, hard: bool = False) -> None:
@@ -786,44 +816,51 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
         MissingEnvironmentError: Missing object storage informations
     """
 
-    target_type, target_path, target_tray, target_base_name  = get_infos_from_path(target_path)
-    link_type, link_path, link_tray, link_base_name  = get_infos_from_path(link_path)
+    target_type, target_path, target_tray, target_base_name = get_infos_from_path(target_path)
+    link_type, link_path, link_tray, link_base_name = get_infos_from_path(link_path)
 
     if target_type != link_type:
-        raise StorageError(f"{target_type.name} and {link_type.name}", f"Cannot make link between two different storage types")
+        raise StorageError(
+            f"{target_type.name} and {link_type.name}",
+            f"Cannot make link between two different storage types",
+        )
 
     if hard and target_type != StorageType.FILE:
         raise StorageError(target_type.name, "Hard link is available only for FILE storage")
 
     # Réalisation du lien, selon les types de stockage
     if target_type == StorageType.S3:
-
         target_s3_client, target_bucket = __get_s3_client(target_tray)
         link_s3_client, link_bucket = __get_s3_client(link_tray)
 
         if target_s3_client["host"] != link_s3_client["host"]:
-            raise StorageError(f"S3", f"Cannot make link {link_path} -> {target_path} : link works only on the same S3 cluster")
+            raise StorageError(
+                f"S3",
+                f"Cannot make link {link_path} -> {target_path} : link works only on the same S3 cluster",
+            )
 
         try:
             target_s3_client["client"].put_object(
-                Body = f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode('utf-8'),
-                Bucket = link_bucket,
-                Key = link_base_name
+                Body=f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode(
+                    "utf-8"
+                ),
+                Bucket=link_bucket,
+                Key=link_base_name,
             )
         except Exception as e:
             raise StorageError("S3", e)
 
     elif target_type == StorageType.CEPH:
-
         ioctx = __get_ceph_ioctx(link_tray)
 
         try:
-            ioctx.write_full(link_base_name, f"{__OBJECT_SYMLINK_SIGNATURE}{target_path}".encode('utf-8'))
+            ioctx.write_full(
+                link_base_name, f"{__OBJECT_SYMLINK_SIGNATURE}{target_path}".encode("utf-8")
+            )
         except Exception as e:
             raise StorageError("CEPH", e)
 
     elif target_type == StorageType.FILE:
-
         try:
             if hard:
                 os.link(target_path, link_path)
@@ -835,6 +872,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
     else:
         raise StorageError("UNKNOWN", "Unhandled storage type to make link")
 
+
 def get_osgeo_path(path: str) -> str:
     """Return GDAL/OGR Open compliant path and configure storage access
 
@@ -852,17 +890,15 @@ def get_osgeo_path(path: str) -> str:
         str: GDAL/OGR Open compliant path
     """
 
-    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
-
+    storage_type, unprefixed_path, tray_name, base_name = get_infos_from_path(path)
 
     if storage_type == StorageType.S3:
-
         s3_client, bucket_name = __get_s3_client(tray_name)
 
-        gdal.SetConfigOption('AWS_SECRET_ACCESS_KEY', s3_client["secret_key"])
-        gdal.SetConfigOption('AWS_ACCESS_KEY_ID', s3_client["key"])
-        gdal.SetConfigOption('AWS_S3_ENDPOINT', s3_client["host"])
-        gdal.SetConfigOption('AWS_VIRTUAL_HOSTING', 'FALSE')
+        gdal.SetConfigOption("AWS_SECRET_ACCESS_KEY", s3_client["secret_key"])
+        gdal.SetConfigOption("AWS_ACCESS_KEY_ID", s3_client["key"])
+        gdal.SetConfigOption("AWS_S3_ENDPOINT", s3_client["host"])
+        gdal.SetConfigOption("AWS_VIRTUAL_HOSTING", "FALSE")
 
         return f"/vsis3/{bucket_name}/{base_name}"
 
diff --git a/src/rok4/TileMatrixSet.py b/src/rok4/TileMatrixSet.py
index 80bd570..472810c 100644
--- a/src/rok4/TileMatrixSet.py
+++ b/src/rok4/TileMatrixSet.py
@@ -18,6 +18,7 @@
 import json
 import os
 
+
 class TileMatrix:
     """A tile matrix is a tile matrix set's level.
 
@@ -30,7 +31,7 @@ class TileMatrix:
         matrix_size (Tuple[int, int]): Number of tile in the level, widthwise and heightwise.
     """
 
-    def __init__(self, level: Dict, tms: 'TileMatrixSet') -> None:
+    def __init__(self, level: Dict, tms: "TileMatrixSet") -> None:
         """Constructor method
 
         Args:
@@ -45,12 +46,25 @@ def __init__(self, level: Dict, tms: 'TileMatrixSet') -> None:
         try:
             self.id = level["id"]
             if self.id.find("_") != -1:
-                raise Exception(f"TMS {tms.path} owns a level whom id contains an underscore ({self.id})")
+                raise Exception(
+                    f"TMS {tms.path} owns a level whom id contains an underscore ({self.id})"
+                )
             self.resolution = level["cellSize"]
-            self.origin = (level["pointOfOrigin"][0], level["pointOfOrigin"][1],)
-            self.tile_size = (level["tileWidth"], level["tileHeight"],)
-            self.matrix_size = (level["matrixWidth"], level["matrixHeight"],)
-            self.__latlon = (self.tms.sr.EPSGTreatsAsLatLong() or self.tms.sr.EPSGTreatsAsNorthingEasting())
+            self.origin = (
+                level["pointOfOrigin"][0],
+                level["pointOfOrigin"][1],
+            )
+            self.tile_size = (
+                level["tileWidth"],
+                level["tileHeight"],
+            )
+            self.matrix_size = (
+                level["matrixWidth"],
+                level["matrixHeight"],
+            )
+            self.__latlon = (
+                self.tms.sr.EPSGTreatsAsLatLong() or self.tms.sr.EPSGTreatsAsNorthingEasting()
+            )
         except KeyError as e:
             raise MissingAttributeError(tms.path, f"tileMatrices[].{e}")
 
@@ -93,14 +107,14 @@ def tile_to_bbox(self, tile_col: int, tile_row: int) -> Tuple[float, float, floa
                 self.origin[1] - self.resolution * (tile_row + 1) * self.tile_size[1],
                 self.origin[0] + self.resolution * tile_col * self.tile_size[0],
                 self.origin[1] - self.resolution * tile_row * self.tile_size[1],
-                self.origin[0] + self.resolution * (tile_col + 1) * self.tile_size[0]
+                self.origin[0] + self.resolution * (tile_col + 1) * self.tile_size[0],
             )
         else:
             return (
                 self.origin[0] + self.resolution * tile_col * self.tile_size[0],
                 self.origin[1] - self.resolution * (tile_row + 1) * self.tile_size[1],
                 self.origin[0] + self.resolution * (tile_col + 1) * self.tile_size[0],
-                self.origin[1] - self.resolution * tile_row * self.tile_size[1]
+                self.origin[1] - self.resolution * tile_row * self.tile_size[1],
             )
 
     def bbox_to_tiles(self, bbox: Tuple[float, float, float, float]) -> Tuple[int, int, int, int]:
@@ -120,14 +134,14 @@ def bbox_to_tiles(self, bbox: Tuple[float, float, float, float]) -> Tuple[int, i
                 self.x_to_column(bbox[1]),
                 self.y_to_row(bbox[2]),
                 self.x_to_column(bbox[3]),
-                self.y_to_row(bbox[0])
+                self.y_to_row(bbox[0]),
             )
         else:
             return (
                 self.x_to_column(bbox[0]),
                 self.y_to_row(bbox[3]),
                 self.x_to_column(bbox[2]),
-                self.y_to_row(bbox[1])
+                self.y_to_row(bbox[1]),
             )
 
     def point_to_indices(self, x: float, y: float) -> Tuple[int, int, int, int]:
@@ -150,7 +164,13 @@ def point_to_indices(self, x: float, y: float) -> Tuple[int, int, int, int]:
             absolute_pixel_column = int((x - self.origin[0]) / self.resolution)
             absolute_pixel_row = int((self.origin[1] - y) / self.resolution)
 
-        return absolute_pixel_column // self.tile_size[0], absolute_pixel_row // self.tile_size[1], absolute_pixel_column % self.tile_size[0], absolute_pixel_row % self.tile_size[1]
+        return (
+            absolute_pixel_column // self.tile_size[0],
+            absolute_pixel_row // self.tile_size[1],
+            absolute_pixel_column % self.tile_size[0],
+            absolute_pixel_row % self.tile_size[1],
+        )
+
 
 class TileMatrixSet:
     """A tile matrix set is multi levels grid definition
@@ -181,7 +201,7 @@ def __init__(self, name: str) -> None:
         self.name = name
 
         try:
-            self.path = os.path.join(os.environ["ROK4_TMS_DIRECTORY"], f"{self.name}.json");
+            self.path = os.path.join(os.environ["ROK4_TMS_DIRECTORY"], f"{self.name}.json")
         except KeyError as e:
             raise MissingEnvironmentError(e)
 
@@ -200,7 +220,9 @@ def __init__(self, name: str) -> None:
                 raise Exception(f"TMS '{self.path}' has no level")
 
             if data["orderedAxes"] != ["X", "Y"] and data["orderedAxes"] != ["Lon", "Lat"]:
-                raise Exception(f"TMS '{self.path}' own invalid axes order : only X/Y or Lon/Lat are handled")
+                raise Exception(
+                    f"TMS '{self.path}' own invalid axes order : only X/Y or Lon/Lat are handled"
+                )
 
         except JSONDecodeError as e:
             raise FormatError("JSON", self.path, e)
@@ -209,9 +231,11 @@ def __init__(self, name: str) -> None:
             raise MissingAttributeError(self.path, e)
 
         except RuntimeError as e:
-            raise Exception(f"Wrong attribute 'crs' ('{self.srs}') in '{self.path}', not recognize by OSR")
+            raise Exception(
+                f"Wrong attribute 'crs' ('{self.srs}') in '{self.path}', not recognize by OSR"
+            )
 
-    def get_level(self, level_id: str) -> 'TileMatrix':
+    def get_level(self, level_id: str) -> "TileMatrix":
         """Get one level according to its identifier
 
         Args:
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index f31f872..da15aef 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -19,13 +19,16 @@ class ColorFormat(Enum):
       a common variable format name. The member's value is
       the allocated bit size associated to this format.
     """
+
     BIT = 1
     UINT8 = 8
     FLOAT32 = 32
 
 
 __SR_BOOK = {}
-def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
+
+
+def srs_to_spatialreference(srs: str) -> "osgeo.osr.SpatialReference":
     """Convert coordinates system as string to OSR spatial reference
 
     Using a cache, to instanciate a Spatial Reference from a string only once.
@@ -43,8 +46,7 @@ def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
     global __SR_BOOK
 
     if srs.upper() not in __SR_BOOK:
-
-        authority, code = srs.split(':', 1)
+        authority, code = srs.split(":", 1)
 
         sr = osr.SpatialReference()
         if authority.upper() == "EPSG":
@@ -54,10 +56,12 @@ def srs_to_spatialreference(srs: str) -> 'osgeo.osr.SpatialReference':
 
         __SR_BOOK[srs.upper()] = sr
 
-
     return __SR_BOOK[srs.upper()]
 
-def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int = 0) -> 'osgeo.ogr.Geometry':
+
+def bbox_to_geometry(
+    bbox: Tuple[float, float, float, float], densification: int = 0
+) -> "osgeo.ogr.Geometry":
     """Convert bbox coordinates to OGR geometry
 
     Args:
@@ -94,7 +98,6 @@ def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int
         ring.AddPoint(bbox[0], bbox[3])
         ring.AddPoint(bbox[0], bbox[1])
 
-
     geom = ogr.Geometry(ogr.wkbPolygon)
     geom.AddGeometry(ring)
     geom.SetCoordinateDimension(2)
@@ -102,8 +105,9 @@ def bbox_to_geometry(bbox: Tuple[float, float, float, float], densification: int
     return geom
 
 
-
-def reproject_bbox(bbox: Tuple[float, float, float, float], srs_src: str, srs_dst: str, densification: int = 5) -> Tuple[float, float, float, float]:
+def reproject_bbox(
+    bbox: Tuple[float, float, float, float], srs_src: str, srs_dst: str, densification: int = 5
+) -> Tuple[float, float, float, float]:
     """Return bounding box in other coordinates system
 
     Points are added to be sure output bounding box contains input bounding box
@@ -119,10 +123,10 @@ def reproject_bbox(bbox: Tuple[float, float, float, float], srs_src: str, srs_ds
     """
 
     sr_src = srs_to_spatialreference(srs_src)
-    sr_src_inv = (sr_src.EPSGTreatsAsLatLong() or sr_src.EPSGTreatsAsNorthingEasting())
+    sr_src_inv = sr_src.EPSGTreatsAsLatLong() or sr_src.EPSGTreatsAsNorthingEasting()
 
     sr_dst = srs_to_spatialreference(srs_dst)
-    sr_dst_inv = (sr_dst.EPSGTreatsAsLatLong() or sr_dst.EPSGTreatsAsNorthingEasting())
+    sr_dst_inv = sr_dst.EPSGTreatsAsLatLong() or sr_dst.EPSGTreatsAsNorthingEasting()
 
     if sr_src.IsSame(sr_dst) and sr_src_inv == sr_dst_inv:
         # Les système sont vraiment les même, avec le même ordre des axes
@@ -144,7 +148,11 @@ def reproject_bbox(bbox: Tuple[float, float, float, float], srs_src: str, srs_ds
     return (env[0], env[2], env[1], env[3])
 
 
-def reproject_point(point: Tuple[float, float], sr_src: 'osgeo.osr.SpatialReference', sr_dst: 'osgeo.osr.SpatialReference') -> Tuple[float, float]:
+def reproject_point(
+    point: Tuple[float, float],
+    sr_src: "osgeo.osr.SpatialReference",
+    sr_dst: "osgeo.osr.SpatialReference",
+) -> Tuple[float, float]:
     """Reproject a point
 
     Args:
@@ -156,8 +164,8 @@ def reproject_point(point: Tuple[float, float], sr_src: 'osgeo.osr.SpatialRefere
         Tuple[float, float]: X/Y in destination spatial reference
     """
 
-    sr_src_inv = (sr_src.EPSGTreatsAsLatLong() or sr_src.EPSGTreatsAsNorthingEasting())
-    sr_dst_inv = (sr_dst.EPSGTreatsAsLatLong() or sr_dst.EPSGTreatsAsNorthingEasting())
+    sr_src_inv = sr_src.EPSGTreatsAsLatLong() or sr_src.EPSGTreatsAsNorthingEasting()
+    sr_dst_inv = sr_dst.EPSGTreatsAsLatLong() or sr_dst.EPSGTreatsAsNorthingEasting()
 
     if sr_src.IsSame(sr_dst) and sr_src_inv == sr_dst_inv:
         # Les système sont vraiment les même, avec le même ordre des axes
@@ -198,31 +206,21 @@ def compute_bbox(source_dataset: gdal.Dataset) -> Tuple:
     height = source_dataset.RasterYSize
     x_range = (
         transform_vector[0],
-        transform_vector[0] + width * transform_vector[1] + height * transform_vector[2]
+        transform_vector[0] + width * transform_vector[1] + height * transform_vector[2],
     )
     y_range = (
         transform_vector[3],
-        transform_vector[3] + width * transform_vector[4] + height * transform_vector[5]
+        transform_vector[3] + width * transform_vector[4] + height * transform_vector[5],
     )
     spatial_ref = source_dataset.GetSpatialRef()
     if spatial_ref is not None and spatial_ref.GetDataAxisToSRSAxisMapping() == [2, 1]:
         # Coordonnées terrain de type (latitude, longitude)
         # => on permute les coordonnées terrain par rapport à l'image
-        bbox = (
-            min(y_range),
-            min(x_range),
-            max(y_range),
-            max(x_range)
-        )
+        bbox = (min(y_range), min(x_range), max(y_range), max(x_range))
     else:
         # Coordonnées terrain de type (longitude, latitude) ou pas de SRS
         # => les coordonnées terrain sont dans le même ordre que celle de l'image
-        bbox = (
-            min(x_range),
-            min(y_range),
-            max(x_range),
-            max(y_range)
-        )
+        bbox = (min(x_range), min(y_range), max(x_range), max(y_range))
     return bbox
 
 
@@ -252,8 +250,12 @@ def compute_format(dataset: gdal.Dataset, path: str = None) -> ColorFormat:
         color_name = gdal.GetColorInterpretationName(color_interpretation)
     compression_regex_match = re.search(r"COMPRESSION\s*=\s*PACKBITS", gdal.Info(dataset))
 
-    if (data_type_name == "Byte" and data_type_size == 8
-        and color_name == "Palette" and compression_regex_match):
+    if (
+        data_type_name == "Byte"
+        and data_type_size == 8
+        and color_name == "Palette"
+        and compression_regex_match
+    ):
         # Compris par libTIFF comme du noir et blanc sur 1 bit
         color_format = ColorFormat.BIT
     elif data_type_name == "Byte" and data_type_size == 8:
@@ -261,6 +263,8 @@ def compute_format(dataset: gdal.Dataset, path: str = None) -> ColorFormat:
     elif data_type_name == "Float32" and data_type_size == 32:
         color_format = ColorFormat.FLOAT32
     else:
-        raise Exception(f"Unsupported color format for image {path} : "
-                        + f"'{data_type_name}' ({data_type_size} bits)")
+        raise Exception(
+            f"Unsupported color format for image {path} : "
+            + f"'{data_type_name}' ({data_type_size} bits)"
+        )
     return color_format
diff --git a/src/rok4/Vector.py b/src/rok4/Vector.py
index 9cb8c00..94e6def 100644
--- a/src/rok4/Vector.py
+++ b/src/rok4/Vector.py
@@ -15,7 +15,8 @@
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
-class Vector :
+
+class Vector:
     """A data vector
 
     Attributes:
@@ -25,7 +26,7 @@ class Vector :
     """
 
     @classmethod
-    def from_file(cls, path: str, **kwargs) -> 'Vector' :
+    def from_file(cls, path: str, **kwargs) -> "Vector":
         """Constructor method of a Vector from a file (Shapefile, Geopackage, CSV and GeoJSON)
 
         Args:
@@ -65,9 +66,8 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
         path_split = path.split("/")
 
         if path_split[0] == "ceph:" or path.endswith(".csv"):
-
-            if path.endswith(".shp") :
-                with tempfile.TemporaryDirectory() as tmp :
+            if path.endswith(".shp"):
+                with tempfile.TemporaryDirectory() as tmp:
                     tmp_path = tmp + "/" + path_split[-1][:-4]
 
                     copy(path, "file://" + tmp_path + ".shp")
@@ -78,99 +78,111 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
 
                     dataSource = ogr.Open(tmp_path + ".shp", 0)
 
-            elif path.endswith(".gpkg") :
-                with tempfile.TemporaryDirectory() as tmp :
+            elif path.endswith(".gpkg"):
+                with tempfile.TemporaryDirectory() as tmp:
                     tmp_path = tmp + "/" + path_split[-1][:-5]
 
                     copy(path, "file://" + tmp_path + ".gpkg")
 
                     dataSource = ogr.Open(tmp_path + ".gpkg", 0)
 
-            elif path.endswith(".geojson") :
-                with tempfile.TemporaryDirectory() as tmp :
+            elif path.endswith(".geojson"):
+                with tempfile.TemporaryDirectory() as tmp:
                     tmp_path = tmp + "/" + path_split[-1][:-8]
 
                     copy(path, "file://" + tmp_path + ".geojson")
 
                     dataSource = ogr.Open(tmp_path + ".geojson", 0)
 
-            elif path.endswith(".csv") :
+            elif path.endswith(".csv"):
                 # Récupération des informations optionnelles
-                if "csv" in kwargs :
+                if "csv" in kwargs:
                     csv = kwargs["csv"]
-                else :
+                else:
                     csv = {}
 
-                if "srs" in csv and csv["srs"] is not None :
+                if "srs" in csv and csv["srs"] is not None:
                     srs = csv["srs"]
-                else :
+                else:
                     srs = "EPSG:2154"
 
-                if "column_x" in csv and csv["column_x"] is not None :
+                if "column_x" in csv and csv["column_x"] is not None:
                     column_x = csv["column_x"]
-                else :
+                else:
                     column_x = "x"
 
-                if "column_y" in csv and csv["column_y"] is not None :
+                if "column_y" in csv and csv["column_y"] is not None:
                     column_y = csv["column_y"]
-                else :
+                else:
                     column_y = "y"
 
-                if "column_wkt" in csv :
+                if "column_wkt" in csv:
                     column_wkt = csv["column_wkt"]
-                else :
+                else:
                     column_wkt = None
 
-                with tempfile.TemporaryDirectory() as tmp :
+                with tempfile.TemporaryDirectory() as tmp:
                     tmp_path = tmp + "/" + path_split[-1][:-4]
                     name_fich = path_split[-1][:-4]
 
                     copy(path, "file://" + tmp_path + ".csv")
 
-                    with tempfile.NamedTemporaryFile(mode='w', suffix=".vrt", dir=tmp, delete=False) as tmp2 :
+                    with tempfile.NamedTemporaryFile(
+                        mode="w", suffix=".vrt", dir=tmp, delete=False
+                    ) as tmp2:
                         vrt_file = "<OGRVRTDataSource>\n"
                         vrt_file += '<OGRVRTLayer name="' + name_fich + '">\n'
                         vrt_file += "<SrcDataSource>" + tmp_path + ".csv</SrcDataSource>\n"
                         vrt_file += "<SrcLayer>" + name_fich + "</SrcLayer>\n"
                         vrt_file += "<LayerSRS>" + srs + "</LayerSRS>\n"
-                        if column_wkt == None :
-                            vrt_file += '<GeometryField encoding="PointFromColumns" x="' + column_x + '" y="' + column_y + '"/>\n'
-                        else :
-                            vrt_file += '<GeometryField encoding="WKT" field="' + column_wkt + '"/>\n'
+                        if column_wkt == None:
+                            vrt_file += (
+                                '<GeometryField encoding="PointFromColumns" x="'
+                                + column_x
+                                + '" y="'
+                                + column_y
+                                + '"/>\n'
+                            )
+                        else:
+                            vrt_file += (
+                                '<GeometryField encoding="WKT" field="' + column_wkt + '"/>\n'
+                            )
                         vrt_file += "</OGRVRTLayer>\n"
                         vrt_file += "</OGRVRTDataSource>"
                         tmp2.write(vrt_file)
                     dataSourceVRT = ogr.Open(tmp2.name, 0)
                     os.remove(tmp2.name)
-                    dataSource=ogr.GetDriverByName("ESRI Shapefile").CopyDataSource(dataSourceVRT, tmp_path + "shp")
+                    dataSource = ogr.GetDriverByName("ESRI Shapefile").CopyDataSource(
+                        dataSourceVRT, tmp_path + "shp"
+                    )
 
-            else :
+            else:
                 raise Exception("This format of file cannot be loaded")
 
-        else :
+        else:
             dataSource = ogr.Open(get_osgeo_path(path), 0)
 
         multipolygon = ogr.Geometry(ogr.wkbGeometryCollection)
-        try :
+        try:
             layer = dataSource.GetLayer()
-        except AttributeError :
+        except AttributeError:
             raise Exception(f"The content of {self.path} cannot be read")
 
         layers = []
-        for i in range (dataSource.GetLayerCount()) :
+        for i in range(dataSource.GetLayerCount()):
             layer = dataSource.GetLayer(i)
             name = layer.GetName()
             count = layer.GetFeatureCount()
             layerDefinition = layer.GetLayerDefn()
             attributes = []
             for j in range(layerDefinition.GetFieldCount()):
-                fieldName =  layerDefinition.GetFieldDefn(j).GetName()
+                fieldName = layerDefinition.GetFieldDefn(j).GetName()
                 fieldTypeCode = layerDefinition.GetFieldDefn(j).GetType()
                 fieldType = layerDefinition.GetFieldDefn(j).GetFieldTypeName(fieldTypeCode)
                 attributes += [(fieldName, fieldType)]
-            for feature in layer :
+            for feature in layer:
                 geom = feature.GetGeometryRef()
-                if geom != None :
+                if geom != None:
                     multipolygon.AddGeometry(geom)
             layers += [(name, count, attributes)]
 
@@ -180,7 +192,7 @@ def from_file(cls, path: str, **kwargs) -> 'Vector' :
         return self
 
     @classmethod
-    def from_parameters(cls, path: str, bbox : tuple, layers : list) -> 'Vector' :
+    def from_parameters(cls, path: str, bbox: tuple, layers: list) -> "Vector":
         """Constructor method of a Vector from a parameters
 
         Args:
diff --git a/tests/test_Layer.py b/tests/test_Layer.py
index 26b0963..0a60d5c 100644
--- a/tests/test_Layer.py
+++ b/tests/test_Layer.py
@@ -8,12 +8,15 @@
 from unittest.mock import *
 from unittest import mock
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Layer.get_data_str', return_value='{"pyramids" : [{"bottom_level" : "10","top_level" : "10","path" : "s3://pyramids/SCAN1000.json"}],"title" : "SCAN1000","bbox":{"east": 11.250000000000997,"west": -5.624999999999043,"north": 52.48278022207774,"south": 40.9798980696195},"styles" : ["normal","hypso"],"abstract" : "Diffusion de la donnée BDORTHO","resampling" : "linear","keywords" : ["PM","TIFF_JPG_UINT8"]}')
-@mock.patch('rok4.Layer.Pyramid.from_descriptor')
-@mock.patch('rok4.Layer.put_data_str', return_value=None)
+@mock.patch(
+    "rok4.Layer.get_data_str",
+    return_value='{"pyramids" : [{"bottom_level" : "10","top_level" : "10","path" : "s3://pyramids/SCAN1000.json"}],"title" : "SCAN1000","bbox":{"east": 11.250000000000997,"west": -5.624999999999043,"north": 52.48278022207774,"south": 40.9798980696195},"styles" : ["normal","hypso"],"abstract" : "Diffusion de la donnée BDORTHO","resampling" : "linear","keywords" : ["PM","TIFF_JPG_UINT8"]}',
+)
+@mock.patch("rok4.Layer.Pyramid.from_descriptor")
+@mock.patch("rok4.Layer.put_data_str", return_value=None)
 def test_descriptor_ok(mocked_put_data_str, mocked_pyramid_class, mocked_get_data_str):
-
     tms_instance = MagicMock()
     tms_instance.srs = "EPSG:3857"
 
@@ -26,7 +29,7 @@ def test_descriptor_ok(mocked_put_data_str, mocked_pyramid_class, mocked_get_dat
         "channels": 3,
         "nodata": "255,255,255",
         "photometric": "rgb",
-        "interpolation": "bicubic"
+        "interpolation": "bicubic",
     }
     pyramid_instance.format = "TIFF_JPG_UINT8"
     pyramid_instance.tms = tms_instance
@@ -37,19 +40,23 @@ def test_descriptor_ok(mocked_put_data_str, mocked_pyramid_class, mocked_get_dat
     try:
         layer = Layer.from_descriptor("s3://layers/SCAN1000.json")
         assert layer.type == PyramidType.RASTER
-        mocked_get_data_str.assert_called_once_with('s3://layers/SCAN1000.json')
+        mocked_get_data_str.assert_called_once_with("s3://layers/SCAN1000.json")
 
         layer.write_descriptor("s3://layers_backup/")
-        mocked_put_data_str.assert_called_once_with('{"title": "SCAN1000", "abstract": "Diffusion de la donn\\u00e9e BDORTHO", "keywords": ["PM", "TIFF_JPG_UINT8"], "wmts": {"authorized": true}, "tms": {"authorized": true}, "bbox": {"south": 40.9798980696195, "west": -5.624999999999043, "north": 52.48278022207774, "east": 11.250000000000997}, "pyramids": [{"bottom_level": "10", "top_level": "10", "path": "s3://pyramids/SCAN1000.json"}], "wms": {"authorized": true, "crs": ["CRS:84", "IGNF:WGS84G", "EPSG:3857", "EPSG:4258", "EPSG:4326"]}, "styles": ["normal", "hypso"], "resampling": "linear"}', 's3://layers_backup/SCAN1000.json')
+        mocked_put_data_str.assert_called_once_with(
+            '{"title": "SCAN1000", "abstract": "Diffusion de la donn\\u00e9e BDORTHO", "keywords": ["PM", "TIFF_JPG_UINT8"], "wmts": {"authorized": true}, "tms": {"authorized": true}, "bbox": {"south": 40.9798980696195, "west": -5.624999999999043, "north": 52.48278022207774, "east": 11.250000000000997}, "pyramids": [{"bottom_level": "10", "top_level": "10", "path": "s3://pyramids/SCAN1000.json"}], "wms": {"authorized": true, "crs": ["CRS:84", "IGNF:WGS84G", "EPSG:3857", "EPSG:4258", "EPSG:4326"]}, "styles": ["normal", "hypso"], "resampling": "linear"}',
+            "s3://layers_backup/SCAN1000.json",
+        )
     except Exception as exc:
         assert False, f"Layer creation from descriptor raises an exception: {exc}"
 
 
-@mock.patch('rok4.Layer.Pyramid.from_descriptor')
-@mock.patch('rok4.Layer.reproject_bbox', return_value=(0, 0, 100, 100))
-@mock.patch('rok4.Layer.put_data_str', return_value=None)
-def test_parameters_vector_ok(mocked_put_data_str, mocked_utils_reproject_bbox, mocked_pyramid_class):
-
+@mock.patch("rok4.Layer.Pyramid.from_descriptor")
+@mock.patch("rok4.Layer.reproject_bbox", return_value=(0, 0, 100, 100))
+@mock.patch("rok4.Layer.put_data_str", return_value=None)
+def test_parameters_vector_ok(
+    mocked_put_data_str, mocked_utils_reproject_bbox, mocked_pyramid_class
+):
     tms_instance = MagicMock()
     tms_instance.srs = "EPSG:3857"
 
@@ -67,29 +74,35 @@ def test_parameters_vector_ok(mocked_put_data_str, mocked_utils_reproject_bbox,
 
     try:
         layer = Layer.from_parameters(
-            [{
-                "path": "file:///home/ign/pyramids/SCAN1000.json",
-                "bottom_level": "10",
-                "top_level": "10"
-            }],
+            [
+                {
+                    "path": "file:///home/ign/pyramids/SCAN1000.json",
+                    "bottom_level": "10",
+                    "top_level": "10",
+                }
+            ],
             "layername",
-            title = "title",
-            abstract = "abstract"
+            title="title",
+            abstract="abstract",
         )
         assert layer.type == PyramidType.VECTOR
         assert layer.geobbox == (0, 0, 100, 100)
         layer.write_descriptor("file:///home/ign/layers/")
-        mocked_put_data_str.assert_called_once_with('{"title": "title", "abstract": "abstract", "keywords": ["VECTOR", "layername"], "wmts": {"authorized": true}, "tms": {"authorized": true}, "bbox": {"south": 0, "west": 0, "north": 100, "east": 100}, "pyramids": [{"bottom_level": "10", "top_level": "10", "path": "file:///home/ign/pyramids/SCAN1000.json"}]}', 'file:///home/ign/layers/layername.json')
+        mocked_put_data_str.assert_called_once_with(
+            '{"title": "title", "abstract": "abstract", "keywords": ["VECTOR", "layername"], "wmts": {"authorized": true}, "tms": {"authorized": true}, "bbox": {"south": 0, "west": 0, "north": 100, "east": 100}, "pyramids": [{"bottom_level": "10", "top_level": "10", "path": "file:///home/ign/pyramids/SCAN1000.json"}]}',
+            "file:///home/ign/layers/layername.json",
+        )
 
     except Exception as exc:
         assert False, f"Layer creation from parameters raises an exception: {exc}"
 
 
-@mock.patch('rok4.Layer.Pyramid.from_descriptor')
-@mock.patch('rok4.Layer.reproject_bbox', return_value=(0, 0, 100, 100))
-@mock.patch('rok4.Layer.put_data_str', return_value=None)
-def test_parameters_raster_ok(mocked_put_data_str, mocked_utils_reproject_bbox, mocked_pyramid_class):
-
+@mock.patch("rok4.Layer.Pyramid.from_descriptor")
+@mock.patch("rok4.Layer.reproject_bbox", return_value=(0, 0, 100, 100))
+@mock.patch("rok4.Layer.put_data_str", return_value=None)
+def test_parameters_raster_ok(
+    mocked_put_data_str, mocked_utils_reproject_bbox, mocked_pyramid_class
+):
     tms_instance = MagicMock()
     tms_instance.srs = "EPSG:3857"
 
@@ -104,7 +117,7 @@ def test_parameters_raster_ok(mocked_put_data_str, mocked_utils_reproject_bbox,
         "channels": 1,
         "nodata": "-99999",
         "photometric": "gray",
-        "interpolation": "nn"
+        "interpolation": "nn",
     }
     pyramid_instance.tms = tms_instance
     pyramid_instance.bottom_level.id = "10"
@@ -115,18 +128,18 @@ def test_parameters_raster_ok(mocked_put_data_str, mocked_utils_reproject_bbox,
 
     try:
         layer = Layer.from_parameters(
-            [{
-                "path": "file:///home/ign/pyramids/RGEALTI.json"
-            }],
+            [{"path": "file:///home/ign/pyramids/RGEALTI.json"}],
             "layername",
-            title = "title",
-            abstract = "abstract"
+            title="title",
+            abstract="abstract",
         )
         assert layer.type == PyramidType.RASTER
         assert layer.geobbox == (0, 0, 100, 100)
         layer.write_descriptor("file:///home/ign/layers/")
-        mocked_put_data_str.assert_called_once_with('{"title": "title", "abstract": "abstract", "keywords": ["RASTER", "layername"], "wmts": {"authorized": true}, "tms": {"authorized": true}, "bbox": {"south": 0, "west": 0, "north": 100, "east": 100}, "pyramids": [{"bottom_level": "10", "top_level": "10", "path": "file:///home/ign/pyramids/RGEALTI.json"}], "wms": {"authorized": true, "crs": ["CRS:84", "IGNF:WGS84G", "EPSG:3857", "EPSG:4258", "EPSG:4326"]}, "styles": ["normal"], "resampling": "nn"}', 'file:///home/ign/layers/layername.json')
-
+        mocked_put_data_str.assert_called_once_with(
+            '{"title": "title", "abstract": "abstract", "keywords": ["RASTER", "layername"], "wmts": {"authorized": true}, "tms": {"authorized": true}, "bbox": {"south": 0, "west": 0, "north": 100, "east": 100}, "pyramids": [{"bottom_level": "10", "top_level": "10", "path": "file:///home/ign/pyramids/RGEALTI.json"}], "wms": {"authorized": true, "crs": ["CRS:84", "IGNF:WGS84G", "EPSG:3857", "EPSG:4258", "EPSG:4326"]}, "styles": ["normal"], "resampling": "nn"}',
+            "file:///home/ign/layers/layername.json",
+        )
 
     except Exception as exc:
         assert False, f"Layer creation from parameters raises an exception: {exc}"
diff --git a/tests/test_Pyramid.py b/tests/test_Pyramid.py
index c1936dd..6eebfd7 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_Pyramid.py
@@ -9,56 +9,73 @@
 from unittest.mock import *
 from unittest import mock
 
-@mock.patch('rok4.Pyramid.get_data_str', side_effect=StorageError('FILE', 'Not found'))
+
+@mock.patch("rok4.Pyramid.get_data_str", side_effect=StorageError("FILE", "Not found"))
 def test_wrong_file(mocked_get_data_str):
     with pytest.raises(StorageError):
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
 
-@mock.patch('rok4.Pyramid.get_data_str', return_value='{"format": "TIFF_PBF_MVT","levels":[{"id": "100","tables":')
+
+@mock.patch(
+    "rok4.Pyramid.get_data_str",
+    return_value='{"format": "TIFF_PBF_MVT","levels":[{"id": "100","tables":',
+)
 def test_bad_json(mocked_get_data_str):
     with pytest.raises(FormatError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
 
-    assert str(exc.value) == "Expected format JSON to read 'file:///pyramid.json' : Expecting value: line 1 column 59 (char 58)"
-    mocked_get_data_str.assert_called_once_with('file:///pyramid.json')
+    assert (
+        str(exc.value)
+        == "Expected format JSON to read 'file:///pyramid.json' : Expecting value: line 1 column 59 (char 58)"
+    )
+    mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
+
 
-@mock.patch('rok4.Pyramid.get_data_str', return_value='{"format": "TIFF_PBF_MVT","levels":[]}')
+@mock.patch("rok4.Pyramid.get_data_str", return_value='{"format": "TIFF_PBF_MVT","levels":[]}')
 def test_missing_tms(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
 
     assert str(exc.value) == "Missing attribute 'tile_matrix_set' in 'file:///pyramid.json'"
-    mocked_get_data_str.assert_called_once_with('file:///pyramid.json')
+    mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.get_data_str', return_value='{"format": "TIFF_PBF_MVT","levels":[{}], "tile_matrix_set": "PM"}')
-@mock.patch('rok4.Pyramid.TileMatrixSet', side_effect=StorageError('FILE', 'TMS not found'))
+@mock.patch(
+    "rok4.Pyramid.get_data_str",
+    return_value='{"format": "TIFF_PBF_MVT","levels":[{}], "tile_matrix_set": "PM"}',
+)
+@mock.patch("rok4.Pyramid.TileMatrixSet", side_effect=StorageError("FILE", "TMS not found"))
 def test_wrong_tms(mocked_tms_constructor, mocked_get_data_str):
     with pytest.raises(StorageError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
 
     assert str(exc.value) == "Issue occured using a FILE storage : TMS not found"
-    mocked_tms_constructor.assert_called_once_with('PM')
-    mocked_get_data_str.assert_called_once_with('file:///pyramid.json')
+    mocked_tms_constructor.assert_called_once_with("PM")
+    mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.get_data_str', return_value='{"format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}')
-@mock.patch('rok4.Pyramid.TileMatrixSet')
+@mock.patch(
+    "rok4.Pyramid.get_data_str",
+    return_value='{"format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}',
+)
+@mock.patch("rok4.Pyramid.TileMatrixSet")
 def test_raster_missing_raster_specifications(mocked_tms_class, mocked_get_data_str):
-
     with pytest.raises(MissingAttributeError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
 
     assert str(exc.value) == "Missing attribute 'raster_specifications' in 'file:///pyramid.json'"
-    mocked_get_data_str.assert_called_once_with('file:///pyramid.json')
+    mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.get_data_str', return_value='{"raster_specifications":{"channels":3,"nodata":"255,0,0","photometric":"rgb","interpolation":"bicubic"}, "format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"unknown"}], "tile_matrix_set": "PM"}')
-@mock.patch('rok4.Pyramid.TileMatrixSet')
+@mock.patch(
+    "rok4.Pyramid.get_data_str",
+    return_value='{"raster_specifications":{"channels":3,"nodata":"255,0,0","photometric":"rgb","interpolation":"bicubic"}, "format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"unknown"}], "tile_matrix_set": "PM"}',
+)
+@mock.patch("rok4.Pyramid.TileMatrixSet")
 def test_wrong_level(mocked_tms_class, mocked_get_data_str):
-
     tms_instance = MagicMock()
     tms_instance.get_level.return_value = None
     tms_instance.name = "PM"
@@ -67,28 +84,37 @@ def test_wrong_level(mocked_tms_class, mocked_get_data_str):
     with pytest.raises(Exception) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
 
-    mocked_tms_class.assert_called_once_with('PM')
-    mocked_get_data_str.assert_called_once_with('file:///pyramid.json')
-    tms_instance.get_level.assert_called_once_with('unknown')
-    assert str(exc.value) == "Pyramid file:///pyramid.json owns a level with the ID 'unknown', not defined in the TMS 'PM'"
+    mocked_tms_class.assert_called_once_with("PM")
+    mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
+    tms_instance.get_level.assert_called_once_with("unknown")
+    assert (
+        str(exc.value)
+        == "Pyramid file:///pyramid.json owns a level with the ID 'unknown', not defined in the TMS 'PM'"
+    )
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.get_data_str', return_value='{"format": "TIFF_PBF_MVT","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}')
-@mock.patch('rok4.Pyramid.TileMatrixSet', autospec=True)
+@mock.patch(
+    "rok4.Pyramid.get_data_str",
+    return_value='{"format": "TIFF_PBF_MVT","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}',
+)
+@mock.patch("rok4.Pyramid.TileMatrixSet", autospec=True)
 def test_vector_missing_tables(mocked_tms_class, mocked_get_data_str):
-
     with pytest.raises(MissingAttributeError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
 
     assert str(exc.value) == "Missing attribute levels[].'tables' in 'file:///pyramid.json'"
-    mocked_get_data_str.assert_called_once_with('file:///pyramid.json')
+    mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.get_data_str', return_value='{"raster_specifications":{"channels":3,"nodata":"255,0,0","photometric":"rgb","interpolation":"bicubic"}, "format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_prefix":"SCAN1000/DATA_0","pool_name":"pool1","type":"CEPH"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}')
-@mock.patch('rok4.Pyramid.TileMatrixSet')
-@mock.patch('rok4.Pyramid.put_data_str', return_value=None)
+@mock.patch(
+    "rok4.Pyramid.get_data_str",
+    return_value='{"raster_specifications":{"channels":3,"nodata":"255,0,0","photometric":"rgb","interpolation":"bicubic"}, "format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_prefix":"SCAN1000/DATA_0","pool_name":"pool1","type":"CEPH"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}',
+)
+@mock.patch("rok4.Pyramid.TileMatrixSet")
+@mock.patch("rok4.Pyramid.put_data_str", return_value=None)
 def test_raster_ok(mocked_put_data_str, mocked_tms_class, mocked_get_data_str):
-
     tms_instance = MagicMock()
     tms_instance.name = "PM"
     tms_instance.srs = "EPSG:3857"
@@ -97,7 +123,7 @@ def test_raster_ok(mocked_put_data_str, mocked_tms_class, mocked_get_data_str):
     tm_instance = MagicMock()
     tm_instance.id = "0"
     tm_instance.resolution = 1
-    tm_instance.point_to_indices.return_value = (0,0,128,157)
+    tm_instance.point_to_indices.return_value = (0, 0, 128, 157)
 
     tms_instance.get_level.return_value = tm_instance
 
@@ -110,7 +136,7 @@ def test_raster_ok(mocked_put_data_str, mocked_tms_class, mocked_get_data_str):
         assert pyramid.name == "sub/pyramid"
         assert pyramid.storage_type == StorageType.CEPH
         assert pyramid.storage_root == "pool1"
-        mocked_get_data_str.assert_called_once_with('ceph://pool1/sub/pyramid.json')
+        mocked_get_data_str.assert_called_once_with("ceph://pool1/sub/pyramid.json")
 
         clone = Pyramid.from_other(pyramid, "titi", {"type": "FILE", "root": "/data/ign"})
         assert clone.name == "titi"
@@ -119,23 +145,33 @@ def test_raster_ok(mocked_put_data_str, mocked_tms_class, mocked_get_data_str):
         assert clone.tile_extension == "jpg"
         assert clone.get_level("0") is not None
         assert clone.get_level("4") is None
-        assert clone.get_infos_from_slab_path("/data/ign/titi/IMAGE/12/00/4A/F7.tif") == (SlabType.DATA, "12", 159, 367)
-        assert clone.get_tile_indices(102458, 6548125, srs = "EPSG:3857") == ("0",0,0,128,157)
-        assert clone.get_tile_indices(43, 2, srs = "EPSG:4326") == ("0",0,0,128,157)
-
+        assert clone.get_infos_from_slab_path("/data/ign/titi/IMAGE/12/00/4A/F7.tif") == (
+            SlabType.DATA,
+            "12",
+            159,
+            367,
+        )
+        assert clone.get_tile_indices(102458, 6548125, srs="EPSG:3857") == ("0", 0, 0, 128, 157)
+        assert clone.get_tile_indices(43, 2, srs="EPSG:4326") == ("0", 0, 0, 128, 157)
 
         assert len(clone.get_levels()) == 1
 
         clone.write_descriptor()
-        mocked_put_data_str.assert_called_once_with('{"tile_matrix_set": "PM", "format": "TIFF_JPG_UINT8", "levels": [{"id": "0", "tiles_per_width": 16, "tiles_per_height": 16, "tile_limits": {"min_col": 0, "max_row": 15, "max_col": 15, "min_row": 0}, "storage": {"type": "FILE", "image_directory": "titi/DATA/0", "path_depth": 2}}], "raster_specifications": {"channels": 3, "nodata": "255,0,0", "photometric": "rgb", "interpolation": "bicubic"}}', 'file:///data/ign/titi.json')
+        mocked_put_data_str.assert_called_once_with(
+            '{"tile_matrix_set": "PM", "format": "TIFF_JPG_UINT8", "levels": [{"id": "0", "tiles_per_width": 16, "tiles_per_height": 16, "tile_limits": {"min_col": 0, "max_row": 15, "max_col": 15, "min_row": 0}, "storage": {"type": "FILE", "image_directory": "titi/DATA/0", "path_depth": 2}}], "raster_specifications": {"channels": 3, "nodata": "255,0,0", "photometric": "rgb", "interpolation": "bicubic"}}',
+            "file:///data/ign/titi.json",
+        )
     except Exception as exc:
         assert False, f"Pyramid creation raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.get_data_str', return_value='{"format": "TIFF_PBF_MVT","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0","tables":[{"name":"table","geometry":"POINT","attributes":[{"type":"bigint","name":"fid","count":1531}]}]}], "tile_matrix_set": "PM"}')
-@mock.patch('rok4.Pyramid.TileMatrixSet')
+@mock.patch(
+    "rok4.Pyramid.get_data_str",
+    return_value='{"format": "TIFF_PBF_MVT","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0","tables":[{"name":"table","geometry":"POINT","attributes":[{"type":"bigint","name":"fid","count":1531}]}]}], "tile_matrix_set": "PM"}',
+)
+@mock.patch("rok4.Pyramid.TileMatrixSet")
 def test_vector_ok(mocked_tms_class, mocked_get_data_str):
-
     try:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
         assert pyramid.get_level("0") is not None
@@ -143,7 +179,7 @@ def test_vector_ok(mocked_tms_class, mocked_get_data_str):
         assert pyramid.name == "pyramid"
         assert pyramid.storage_depth == 2
         assert pyramid.storage_type == StorageType.FILE
-        mocked_get_data_str.assert_called_once_with('file:///pyramid.json')
+        mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
 
         clone = Pyramid.from_other(pyramid, "toto", {"type": "S3", "root": "bucket"})
         assert clone.name == "toto"
@@ -159,16 +195,15 @@ def test_vector_ok(mocked_tms_class, mocked_get_data_str):
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.TileMatrixSet')
+@mock.patch("rok4.Pyramid.TileMatrixSet")
 def test_tile_read_raster(mocked_tms_class):
-
     tms_instance = MagicMock()
     tms_instance.name = "UTM20W84MART_1M_MNT"
     tms_instance.srs = "IGNF:UTM20W84MART"
 
     tm_instance = MagicMock()
     tm_instance.id = "8"
-    tm_instance.tile_size = (256,256)
+    tm_instance.tile_size = (256, 256)
 
     tms_instance.get_level.return_value = tm_instance
 
@@ -176,26 +211,24 @@ def test_tile_read_raster(mocked_tms_class):
 
     try:
         pyramid = Pyramid.from_descriptor("file://tests/fixtures/TIFF_ZIP_FLOAT32.json")
-        data = pyramid.get_tile_data_raster("8",2748,40537)
+        data = pyramid.get_tile_data_raster("8", 2748, 40537)
 
-        assert data.shape == (256,256,1)
+        assert data.shape == (256, 256, 1)
         assert data[128][128][0] == 447.25
     except Exception as exc:
         assert False, f"Pyramid raster tile read raises an exception: {exc}"
 
 
-
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.TileMatrixSet')
+@mock.patch("rok4.Pyramid.TileMatrixSet")
 def test_tile_read_vector(mocked_tms_class):
-
     tms_instance = MagicMock()
     tms_instance.name = "PM"
     tms_instance.srs = "EPSG:3857"
 
     tm_instance = MagicMock()
     tm_instance.id = "4"
-    tm_instance.tile_size = (256,256)
+    tm_instance.tile_size = (256, 256)
 
     tms_instance.get_level.return_value = tm_instance
 
@@ -215,16 +248,15 @@ def test_tile_read_vector(mocked_tms_class):
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('rok4.Pyramid.TileMatrixSet')
+@mock.patch("rok4.Pyramid.TileMatrixSet")
 def test_list_read(mocked_tms_class):
-
     tms_instance = MagicMock()
     tms_instance.name = "PM"
     tms_instance.srs = "EPSG:3857"
 
     tm_instance = MagicMock()
     tm_instance.id = "4"
-    tm_instance.tile_size = (256,256)
+    tm_instance.tile_size = (256, 256)
 
     tms_instance.get_level.return_value = tm_instance
 
@@ -233,22 +265,37 @@ def test_list_read(mocked_tms_class):
     try:
         pyramid = Pyramid.from_descriptor("file://tests/fixtures/TIFF_PBF_MVT.json")
         pyramid.load_list()
-        pyramid.load_list() # on passe par la détection d'une liste déjà chrargée ainsi
+        pyramid.load_list()  # on passe par la détection d'une liste déjà chrargée ainsi
         for (slab_type, level, column, row), infos in pyramid.list_generator():
             assert slab_type == SlabType.DATA
-            assert level == '4'
+            assert level == "4"
             assert column == 2
             assert row == 1
-            assert infos == {'link': False, 'md5': None, 'root': 'TIFF_PBF_MVT', 'slab': 'DATA/4/00/00/21.tif'}
+            assert infos == {
+                "link": False,
+                "md5": None,
+                "root": "TIFF_PBF_MVT",
+                "slab": "DATA/4/00/00/21.tif",
+            }
 
     except Exception as exc:
         assert False, f"Pyramid vector list read raises an exception: {exc}"
 
 
 def test_b36_path_decode():
-    assert b36_path_decode("3E/42/01.tif") == (4032, 18217,)
-    assert b36_path_decode("3E/42/01.TIFF") == (4032, 18217,)
-    assert b36_path_decode("3E/42/01") == (4032, 18217,)
+    assert b36_path_decode("3E/42/01.tif") == (
+        4032,
+        18217,
+    )
+    assert b36_path_decode("3E/42/01.TIFF") == (
+        4032,
+        18217,
+    )
+    assert b36_path_decode("3E/42/01") == (
+        4032,
+        18217,
+    )
+
 
 def test_b36_path_encode():
     assert b36_path_encode(4032, 18217, 2) == "3E/42/01.tif"
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index 608c3e2..de35de1 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -28,10 +28,16 @@ def test_default(self):
         raster = Raster()
 
         assert raster.bands is None
-        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
-                and all(coordinate is None for coordinate in raster.bbox))
-        assert (isinstance(raster.dimensions, tuple) and len(raster.dimensions) == 2
-                and all(dimension is None for dimension in raster.dimensions))
+        assert (
+            isinstance(raster.bbox, tuple)
+            and len(raster.bbox) == 4
+            and all(coordinate is None for coordinate in raster.bbox)
+        )
+        assert (
+            isinstance(raster.dimensions, tuple)
+            and len(raster.dimensions) == 2
+            and all(dimension is None for dimension in raster.dimensions)
+        )
         assert raster.format is None
         assert raster.mask is None
         assert raster.path is None
@@ -66,12 +72,14 @@ def test_image_not_found(self, m_exists):
     @mock.patch("rok4.Raster.gdal.Open")
     @mock.patch("rok4.Raster.compute_bbox")
     @mock.patch("rok4.Raster.exists", side_effect=[True, False])
-    def test_image(self, m_exists, m_compute_bbox, m_gdal_open, m_compute_format,
-                   m_get_osgeo_path):
+    def test_image(self, m_exists, m_compute_bbox, m_gdal_open, m_compute_format, m_get_osgeo_path):
         """Constructor called nominally on an image without mask."""
         m_compute_bbox.return_value = self.bbox
-        m_dataset_properties = {"RasterCount": 3, "RasterXSize": self.image_size[0],
-                                "RasterYSize": self.image_size[1]}
+        m_dataset_properties = {
+            "RasterCount": 3,
+            "RasterXSize": self.image_size[0],
+            "RasterYSize": self.image_size[1],
+        }
         m_gdal_open.return_value = type("", (object,), m_dataset_properties)
         m_get_osgeo_path.return_value = self.osgeo_image_path
 
@@ -83,11 +91,14 @@ def test_image(self, m_exists, m_compute_bbox, m_gdal_open, m_compute_format,
         assert raster.path == self.source_image_path
         assert raster.mask is None
         m_compute_bbox.assert_called_once()
-        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
-                and math.isclose(raster.bbox[0], self.bbox[0], rel_tol=1e-5)
-                and math.isclose(raster.bbox[1], self.bbox[1], rel_tol=1e-5)
-                and math.isclose(raster.bbox[2], self.bbox[2], rel_tol=1e-5)
-                and math.isclose(raster.bbox[3], self.bbox[3], rel_tol=1e-5))
+        assert (
+            isinstance(raster.bbox, tuple)
+            and len(raster.bbox) == 4
+            and math.isclose(raster.bbox[0], self.bbox[0], rel_tol=1e-5)
+            and math.isclose(raster.bbox[1], self.bbox[1], rel_tol=1e-5)
+            and math.isclose(raster.bbox[2], self.bbox[2], rel_tol=1e-5)
+            and math.isclose(raster.bbox[3], self.bbox[3], rel_tol=1e-5)
+        )
         assert raster.bands == 3
         m_compute_format.assert_called_once()
         assert raster.format == ColorFormat.UINT8
@@ -99,31 +110,45 @@ def test_image(self, m_exists, m_compute_bbox, m_gdal_open, m_compute_format,
     @mock.patch("rok4.Raster.gdal.Open")
     @mock.patch("rok4.Raster.compute_bbox")
     @mock.patch("rok4.Raster.exists", side_effect=[True, True])
-    def test_image_and_mask(self, m_exists, m_compute_bbox, m_gdal_open, m_identifydriver,
-                            m_compute_format, m_get_osgeo_path):
+    def test_image_and_mask(
+        self,
+        m_exists,
+        m_compute_bbox,
+        m_gdal_open,
+        m_identifydriver,
+        m_compute_format,
+        m_get_osgeo_path,
+    ):
         """Constructor called nominally on an image with mask."""
         m_compute_bbox.return_value = self.bbox
-        m_dataset_properties = {"RasterCount": 3, "RasterXSize": self.image_size[0],
-                                "RasterYSize": self.image_size[1]}
+        m_dataset_properties = {
+            "RasterCount": 3,
+            "RasterXSize": self.image_size[0],
+            "RasterYSize": self.image_size[1],
+        }
         m_gdal_open.return_value = type("", (object,), m_dataset_properties)
-        m_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
+        m_get_osgeo_path.side_effect = [self.osgeo_image_path, self.osgeo_mask_path]
         m_identifydriver.return_value = type("", (object,), {"ShortName": "GTiff"})
 
         raster = Raster.from_file(self.source_image_path)
 
         m_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
-        m_get_osgeo_path.assert_has_calls([call(self.source_image_path),
-                                                call(self.source_mask_path)])
+        m_get_osgeo_path.assert_has_calls(
+            [call(self.source_image_path), call(self.source_mask_path)]
+        )
         m_identifydriver.assert_called_once_with(self.osgeo_mask_path)
         m_gdal_open.assert_called_once_with(self.osgeo_image_path)
         assert raster.path == self.source_image_path
         assert raster.mask == self.source_mask_path
         m_compute_bbox.assert_called_once()
-        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
-                and math.isclose(raster.bbox[0], self.bbox[0], rel_tol=1e-5)
-                and math.isclose(raster.bbox[1], self.bbox[1], rel_tol=1e-5)
-                and math.isclose(raster.bbox[2], self.bbox[2], rel_tol=1e-5)
-                and math.isclose(raster.bbox[3], self.bbox[3], rel_tol=1e-5))
+        assert (
+            isinstance(raster.bbox, tuple)
+            and len(raster.bbox) == 4
+            and math.isclose(raster.bbox[0], self.bbox[0], rel_tol=1e-5)
+            and math.isclose(raster.bbox[1], self.bbox[1], rel_tol=1e-5)
+            and math.isclose(raster.bbox[2], self.bbox[2], rel_tol=1e-5)
+            and math.isclose(raster.bbox[3], self.bbox[3], rel_tol=1e-5)
+        )
         assert raster.bands == 3
         m_compute_format.assert_called_once()
         assert raster.format == ColorFormat.UINT8
@@ -147,18 +172,20 @@ def test_unsupported_image_format(self, m_exists, m_gdal_open, m_get_osgeo_path)
     @mock.patch("rok4.Raster.gdal.IdentifyDriver")
     @mock.patch("rok4.Raster.gdal.Open", side_effect=None)
     @mock.patch("rok4.Raster.exists", side_effect=[True, True])
-    def test_unsupported_mask_format(self, m_exists, m_gdal_open, m_identifydriver,
-                                     m_get_osgeo_path):
+    def test_unsupported_mask_format(
+        self, m_exists, m_gdal_open, m_identifydriver, m_get_osgeo_path
+    ):
         """Test case : Constructor called on an unsupported mask file or object."""
-        m_get_osgeo_path.side_effect=[self.osgeo_image_path, self.osgeo_mask_path]
+        m_get_osgeo_path.side_effect = [self.osgeo_image_path, self.osgeo_mask_path]
         m_identifydriver.return_value = type("", (object,), {"ShortName": "JPG"})
 
         with pytest.raises(Exception):
             Raster.from_file(self.source_image_path)
 
         m_exists.assert_has_calls([call(self.source_image_path), call(self.source_mask_path)])
-        m_get_osgeo_path.assert_has_calls([call(self.source_image_path),
-                                                call(self.source_mask_path)])
+        m_get_osgeo_path.assert_has_calls(
+            [call(self.source_image_path), call(self.source_mask_path)]
+        )
         m_identifydriver.assert_called_once_with(self.osgeo_mask_path)
         m_gdal_open.assert_called_once_with(self.osgeo_image_path)
 
@@ -173,24 +200,26 @@ def test_image(self):
             "bbox": (-5.4, 41.3, 9.8, 51.3),
             "dimensions": (1920, 1080),
             "format": ColorFormat.UINT8,
-            "path": "file:///path/to/image.tif"
+            "path": "file:///path/to/image.tif",
         }
 
         raster = Raster.from_parameters(**parameters)
 
         assert raster.path == parameters["path"]
-        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
-                and math.isclose(raster.bbox[0], parameters["bbox"][0], rel_tol=1e-5)
-                and math.isclose(raster.bbox[1], parameters["bbox"][1], rel_tol=1e-5)
-                and math.isclose(raster.bbox[2], parameters["bbox"][2], rel_tol=1e-5)
-                and math.isclose(raster.bbox[3], parameters["bbox"][3], rel_tol=1e-5))
+        assert (
+            isinstance(raster.bbox, tuple)
+            and len(raster.bbox) == 4
+            and math.isclose(raster.bbox[0], parameters["bbox"][0], rel_tol=1e-5)
+            and math.isclose(raster.bbox[1], parameters["bbox"][1], rel_tol=1e-5)
+            and math.isclose(raster.bbox[2], parameters["bbox"][2], rel_tol=1e-5)
+            and math.isclose(raster.bbox[3], parameters["bbox"][3], rel_tol=1e-5)
+        )
         assert raster.bands == parameters["bands"]
         assert raster.format == parameters["format"]
         assert raster.dimensions == parameters["dimensions"]
         assert raster.mask is None
 
     def test_image_and_mask(self):
-
         """Parameters describing an image with mask"""
         parameters = {
             "bands": 4,
@@ -198,17 +227,20 @@ def test_image_and_mask(self):
             "dimensions": (1920, 1080),
             "format": ColorFormat.UINT8,
             "mask": "file:///path/to/image.msk",
-            "path": "file:///path/to/image.tif"
+            "path": "file:///path/to/image.tif",
         }
 
         raster = Raster.from_parameters(**parameters)
 
         assert raster.path == parameters["path"]
-        assert (isinstance(raster.bbox, tuple) and len(raster.bbox) == 4
-                and math.isclose(raster.bbox[0], parameters["bbox"][0], rel_tol=1e-5)
-                and math.isclose(raster.bbox[1], parameters["bbox"][1], rel_tol=1e-5)
-                and math.isclose(raster.bbox[2], parameters["bbox"][2], rel_tol=1e-5)
-                and math.isclose(raster.bbox[3], parameters["bbox"][3], rel_tol=1e-5))
+        assert (
+            isinstance(raster.bbox, tuple)
+            and len(raster.bbox) == 4
+            and math.isclose(raster.bbox[0], parameters["bbox"][0], rel_tol=1e-5)
+            and math.isclose(raster.bbox[1], parameters["bbox"][1], rel_tol=1e-5)
+            and math.isclose(raster.bbox[2], parameters["bbox"][2], rel_tol=1e-5)
+            and math.isclose(raster.bbox[3], parameters["bbox"][3], rel_tol=1e-5)
+        )
         assert raster.bands == parameters["bands"]
         assert raster.format == parameters["format"]
         assert raster.dimensions == parameters["dimensions"]
@@ -225,10 +257,13 @@ def test_default(self):
         """Default property values."""
         rasterset = RasterSet()
 
-        assert (isinstance(rasterset.bbox, tuple) and len(rasterset.bbox) == 4
-                and all(coordinate is None for coordinate in rasterset.bbox))
-        assert (isinstance(rasterset.colors, list) and not rasterset.colors)
-        assert (isinstance(rasterset.raster_list, list) and not rasterset.raster_list)
+        assert (
+            isinstance(rasterset.bbox, tuple)
+            and len(rasterset.bbox) == 4
+            and all(coordinate is None for coordinate in rasterset.bbox)
+        )
+        assert isinstance(rasterset.colors, list) and not rasterset.colors
+        assert isinstance(rasterset.raster_list, list) and not rasterset.raster_list
         assert rasterset.srs is None
 
 
@@ -244,27 +279,23 @@ def test_ok_at_least_3_files(self, m_from_file, m_get_osgeo_path):
         for n in range(0, file_number, 1):
             file_list.append(f"s3://test_bucket/image_{n+1}.tif")
         file_list_string = "\n".join(file_list)
-        m_open = mock_open(read_data = file_list_string)
+        m_open = mock_open(read_data=file_list_string)
         list_path = "s3://test_bucket/raster_set.list"
         list_local_path = "/tmp/raster_set.list"
         m_get_osgeo_path.return_value = list_local_path
         raster_list = []
         colors = []
-        serial_in = {
-            "raster_list": [],
-            "colors": []
-        }
+        serial_in = {"raster_list": [], "colors": []}
         for n in range(0, file_number, 1):
             raster = MagicMock(Raster)
             raster.path = file_list[n]
             raster.bbox = (
-                -0.75 + math.floor(n/3),
-                -1.33 + n - 3 * math.floor(n/3),
-                0.25 + math.floor(n/3),
-                -0.33 +  n - 3 * math.floor(n/3)
+                -0.75 + math.floor(n / 3),
+                -1.33 + n - 3 * math.floor(n / 3),
+                0.25 + math.floor(n / 3),
+                -0.33 + n - 3 * math.floor(n / 3),
             )
-            raster.format = random.choice([ColorFormat.BIT, ColorFormat.UINT8,
-                                          ColorFormat.FLOAT32])
+            raster.format = random.choice([ColorFormat.BIT, ColorFormat.UINT8, ColorFormat.FLOAT32])
             if raster.format == ColorFormat.BIT:
                 raster.bands = 1
             else:
@@ -276,25 +307,23 @@ def test_ok_at_least_3_files(self, m_from_file, m_get_osgeo_path):
             color_dict = {"bands": raster.bands, "format": raster.format}
             if color_dict not in colors:
                 colors.append(color_dict)
-                serial_in["colors"].append({"bands": raster.bands,
-                                               "format": raster.format.name})
+                serial_in["colors"].append({"bands": raster.bands, "format": raster.format.name})
             raster.dimensions = (5000, 5000)
             raster_list.append(raster)
-            raster_serial = {"path": raster.path, "bands": raster.bands,
-                                   "format": raster.format.name, "bbox": list(raster.bbox),
-                                   "dimensions": list(raster.dimensions)}
+            raster_serial = {
+                "path": raster.path,
+                "bands": raster.bands,
+                "format": raster.format.name,
+                "bbox": list(raster.bbox),
+                "dimensions": list(raster.dimensions),
+            }
             if raster.mask:
                 raster_serial["mask"] = raster.mask
             serial_in["raster_list"].append(raster_serial)
         m_from_file.side_effect = raster_list
         srs = "EPSG:4326"
         serial_in["srs"] = srs
-        bbox = (
-            -0.75,
-            -1.33,
-            0.25 + math.floor((file_number-1)/3),
-            1.67
-        )
+        bbox = (-0.75, -1.33, 0.25 + math.floor((file_number - 1) / 3), 1.67)
         serial_in["bbox"] = list(bbox)
 
         with mock.patch("rok4.Raster.open", m_open):
@@ -333,7 +362,7 @@ def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "file:///path/to/images/550000_6220000.msk",
-                    "path": "file:///path/to/images/550000_6220000.tif"
+                    "path": "file:///path/to/images/550000_6220000.tif",
                 },
                 {
                     "bands": 3,
@@ -341,7 +370,7 @@ def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "file:///path/to/images/560000_6220000.msk",
-                    "path": "file:///path/to/images/560000_6220000.tif"
+                    "path": "file:///path/to/images/560000_6220000.tif",
                 },
                 {
                     "bands": 3,
@@ -349,10 +378,10 @@ def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "file:///path/to/images/550000_6230000.msk",
-                    "path": "file:///path/to/images/550000_6230000.tif"
-                }
+                    "path": "file:///path/to/images/550000_6230000.tif",
+                },
             ],
-            "srs": "IGNF:LAMB93"
+            "srs": "IGNF:LAMB93",
         }
         desc_path = "file:///path/to/descriptor.json"
         local_path = "/path/to/descriptor.json"
@@ -370,7 +399,7 @@ def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
             raster_args_list.append(raster_properties)
         m_from_parameters.side_effect = raster_list
         m_get_osgeo_path.return_value = local_path
-        m_open = mock_open(read_data = desc_content)
+        m_open = mock_open(read_data=desc_content)
 
         with mock.patch("rok4.Raster.open", m_open):
             rasterset = RasterSet.from_descriptor(desc_path)
@@ -383,15 +412,14 @@ def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
         for i in range(0, len(raster_args_list), 1):
             assert m_from_parameters.call_args_list[i] == call(**raster_args_list[i])
         assert rasterset.raster_list == raster_list
-        assert (isinstance(rasterset.bbox, tuple) and len(rasterset.bbox) == 4)
+        assert isinstance(rasterset.bbox, tuple) and len(rasterset.bbox) == 4
         assert isinstance(rasterset.colors, list) and rasterset.colors
         for i in range(0, len(serial_in["colors"]), 1):
             expected_color = copy.deepcopy(serial_in["colors"][i])
             expected_color["format"] = ColorFormat[serial_in["colors"][i]["format"]]
             assert rasterset.colors[i] == expected_color
         serial_out = rasterset.serializable
-        assert (isinstance(serial_out["bbox"], list)
-                and len(serial_out["bbox"]) == 4)
+        assert isinstance(serial_out["bbox"], list) and len(serial_out["bbox"]) == 4
         for i in range(0, 4, 1):
             assert math.isclose(rasterset.bbox[i], serial_in["bbox"][i], rel_tol=1e-5)
             assert math.isclose(serial_out["bbox"][i], serial_in["bbox"][i], rel_tol=1e-5)
@@ -415,7 +443,7 @@ def test_ok_with_output_path(self, m_put_data_str):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/550000_6220000.msk",
-                    "path": "s3://rok4bucket/images/550000_6220000.tif"
+                    "path": "s3://rok4bucket/images/550000_6220000.tif",
                 },
                 {
                     "bands": 3,
@@ -423,7 +451,7 @@ def test_ok_with_output_path(self, m_put_data_str):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/560000_6220000.msk",
-                    "path": "s3://rok4bucket/images/560000_6220000.tif"
+                    "path": "s3://rok4bucket/images/560000_6220000.tif",
                 },
                 {
                     "bands": 3,
@@ -431,10 +459,10 @@ def test_ok_with_output_path(self, m_put_data_str):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/550000_6230000.msk",
-                    "path": "s3://rok4bucket/images/550000_6230000.tif"
-                }
+                    "path": "s3://rok4bucket/images/550000_6230000.tif",
+                },
             ],
-            "srs": "IGNF:LAMB93"
+            "srs": "IGNF:LAMB93",
         }
         content = json.dumps(serial_in, sort_keys=True)
         path = "s3://rok4bucket/dst_descriptor.json"
@@ -443,8 +471,9 @@ def test_ok_with_output_path(self, m_put_data_str):
         rasterset.srs = serial_in["srs"]
         rasterset.colors = []
         for color_dict in serial_in["colors"]:
-            rasterset.colors.append({"bands": color_dict["bands"],
-                                     "format": ColorFormat[color_dict["format"]]})
+            rasterset.colors.append(
+                {"bands": color_dict["bands"], "format": ColorFormat[color_dict["format"]]}
+            )
         rasterset.raster_list = []
         for raster_dict in serial_in["raster_list"]:
             raster_args = copy.deepcopy(raster_dict)
@@ -460,7 +489,6 @@ def test_ok_with_output_path(self, m_put_data_str):
 
         m_put_data_str.assert_called_once_with(content, path)
 
-
     @mock.patch("rok4.Raster.print")
     def test_ok_no_output_path(self, m_print):
         serial_in = {
@@ -473,7 +501,7 @@ def test_ok_no_output_path(self, m_print):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/550000_6220000.msk",
-                    "path": "s3://rok4bucket/images/550000_6220000.tif"
+                    "path": "s3://rok4bucket/images/550000_6220000.tif",
                 },
                 {
                     "bands": 3,
@@ -481,7 +509,7 @@ def test_ok_no_output_path(self, m_print):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/560000_6220000.msk",
-                    "path": "s3://rok4bucket/images/560000_6220000.tif"
+                    "path": "s3://rok4bucket/images/560000_6220000.tif",
                 },
                 {
                     "bands": 3,
@@ -489,10 +517,10 @@ def test_ok_no_output_path(self, m_print):
                     "dimensions": [5000, 5000],
                     "format": "UINT8",
                     "mask": "s3://rok4bucket/images/550000_6230000.msk",
-                    "path": "s3://rok4bucket/images/550000_6230000.tif"
-                }
+                    "path": "s3://rok4bucket/images/550000_6230000.tif",
+                },
             ],
-            "srs": "IGNF:LAMB93"
+            "srs": "IGNF:LAMB93",
         }
         content = json.dumps(serial_in, sort_keys=True)
         rasterset = RasterSet()
@@ -500,8 +528,9 @@ def test_ok_no_output_path(self, m_print):
         rasterset.srs = serial_in["srs"]
         rasterset.colors = []
         for color_dict in serial_in["colors"]:
-            rasterset.colors.append({"bands": color_dict["bands"],
-                                     "format": ColorFormat[color_dict["format"]]})
+            rasterset.colors.append(
+                {"bands": color_dict["bands"], "format": ColorFormat[color_dict["format"]]}
+            )
         rasterset.raster_list = []
         for raster_dict in serial_in["raster_list"]:
             raster_args = copy.deepcopy(raster_dict)
@@ -516,4 +545,3 @@ def test_ok_no_output_path(self, m_print):
             assert False, f"Writing RasterSet's descriptor raises an exception: {exc}"
 
         m_print.assert_called_once_with(content)
-
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 69d2ece..0bd45ac 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -10,32 +10,48 @@
 from unittest import mock
 from unittest.mock import *
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @patch("builtins.open", new_callable=mock_open, read_data=b"data")
 def test_hash_file_ok(mock_file):
     try:
         md5 = hash_file("/path/to/file.ext")
-        mock_file.assert_called_with("/path/to/file.ext", 'rb')
+        mock_file.assert_called_with("/path/to/file.ext", "rb")
         assert md5 == "8d777f385d3dfec8815d20f7496026dc"
     except Exception as exc:
         assert False, f"FILE md5 sum raises an exception: {exc}"
 
+
 @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")
-    assert (StorageType.CEPH, "toto/titi/tutu", "toto", "titi/tutu") == get_infos_from_path("ceph://toto/titi/tutu")
-    assert (StorageType.FILE, "wrong://toto/titi", "wrong://toto", "titi") == get_infos_from_path("wrong://toto/titi")
+    assert (
+        StorageType.FILE,
+        "/toto/titi/tutu.json",
+        "/toto/titi",
+        "tutu.json",
+    ) == get_infos_from_path("file:///toto/titi/tutu.json")
+    assert (StorageType.CEPH, "toto/titi/tutu", "toto", "titi/tutu") == get_infos_from_path(
+        "ceph://toto/titi/tutu"
+    )
+    assert (StorageType.FILE, "wrong://toto/titi", "wrong://toto", "titi") == get_infos_from_path(
+        "wrong://toto/titi"
+    )
 
 
 @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"
+    assert (
+        get_path_from_infos(StorageType.FILE, "/toto/titi", "tutu.json")
+        == "file:///toto/titi/tutu.json"
+    )
     assert get_path_from_infos(StorageType.CEPH, "toto", "titi/tutu") == "ceph://toto/titi/tutu"
 
+
 ############ get_data_str
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_s3_missing_env():
     with pytest.raises(MissingEnvironmentError):
@@ -47,16 +63,24 @@ def test_ceph_missing_env():
     with pytest.raises(MissingEnvironmentError):
         data = get_data_str("ceph://bucket/path/to/object")
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "a,b", "ROK4_S3_SECRETKEY": "b,c", "ROK4_S3_KEY": "c,d,e"}, clear=True)
+
+@mock.patch.dict(
+    os.environ,
+    {"ROK4_S3_URL": "a,b", "ROK4_S3_SECRETKEY": "b,c", "ROK4_S3_KEY": "c,d,e"},
+    clear=True,
+)
 def test_s3_invalid_envs():
     with pytest.raises(StorageError):
         data = get_data_str("s3://bucket/path/to/object")
 
-@mock.patch.dict(os.environ, {"ROK4_S3_URL": "a", "ROK4_S3_SECRETKEY": "b", "ROK4_S3_KEY": "c"}, clear=True)
-@mock.patch('rok4.Storage.boto3.client')
+
+@mock.patch.dict(
+    os.environ, {"ROK4_S3_URL": "a", "ROK4_S3_SECRETKEY": "b", "ROK4_S3_KEY": "c"}, clear=True
+)
+@mock.patch("rok4.Storage.boto3.client")
 def test_s3_invalid_endpoint(mocked_s3_client):
     s3_instance = MagicMock()
-    mocked_s3_client.side_effect = Exception('Invalid URL')
+    mocked_s3_client.side_effect = Exception("Invalid URL")
     with pytest.raises(StorageError):
         data = get_data_str("s3://bucket/path/to/object")
 
@@ -80,27 +104,34 @@ 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('rok4.Storage.boto3.client')
+
+@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()
     s3_instance = MagicMock()
-    s3_instance.get_object.side_effect = Exception('Bucket or object not found')
+    s3_instance.get_object.side_effect = Exception("Bucket or object not found")
     mocked_s3_client.return_value = s3_instance
     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('rok4.Storage.boto3.client')
-def test_s3_read_ok(mocked_s3_client):
 
+@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):
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_body = MagicMock()
     s3_body.read.return_value = b"data"
-    s3_instance.get_object.return_value = {
-        "Body": s3_body
-    }
+    s3_instance.get_object.return_value = {"Body": s3_body}
     mocked_s3_client.return_value = s3_instance
 
     try:
@@ -110,10 +141,13 @@ 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('rok4.Storage.rados.Rados')
+@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):
-
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.stat.return_value = (4, "date")
@@ -131,23 +165,30 @@ 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('rok4.Storage.boto3.client')
-def test_s3_write_nok(mocked_s3_client):
 
+@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):
     disconnect_s3_clients()
     s3_instance = MagicMock()
-    s3_instance.put_object.side_effect = Exception('Cannot write S3 object')
+    s3_instance.put_object.side_effect = Exception("Cannot write S3 object")
     mocked_s3_client.return_value = s3_instance
 
     with pytest.raises(StorageError):
         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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.put_object.return_value = None
@@ -158,10 +199,13 @@ 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('rok4.Storage.rados.Rados')
+@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):
-
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.write_full.return_value = None
@@ -174,12 +218,14 @@ def test_ceph_write_ok(mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH write raises an exception: {exc}"
 
+
 ############ copy
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('os.makedirs', return_value=None)
-@mock.patch('rok4.Storage.copyfile', return_value=None)
-@mock.patch('rok4.Storage.hash_file', return_value="toto")
+@mock.patch("os.makedirs", return_value=None)
+@mock.patch("rok4.Storage.copyfile", return_value=None)
+@mock.patch("rok4.Storage.hash_file", return_value="toto")
 def test_copy_file_file_ok(mock_hash_file, mock_copyfile, mock_makedirs):
     try:
         copy("file:///path/to/source.ext", "file:///path/to/destination.ext", "toto")
@@ -190,19 +236,21 @@ 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('rok4.Storage.boto3.client')
-@mock.patch('os.makedirs', return_value=None)
-@mock.patch('rok4.Storage.hash_file', return_value="toto")
+@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")
 def test_copy_s3_file_ok(mock_hash_file, mock_makedirs, mocked_s3_client):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.download_file.return_value = None
     mocked_s3_client.return_value = s3_instance
 
     try:
-
         copy("s3://bucket/source.ext", "file:///path/to/destination.ext", "toto")
         mock_hash_file.assert_called_once_with("/path/to/destination.ext")
         mock_makedirs.assert_called_once_with("/path/to", exist_ok=True)
@@ -210,15 +258,18 @@ 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('rok4.Storage.boto3.client')
-@mock.patch('os.makedirs', return_value=None)
-@mock.patch('rok4.Storage.hash_file', return_value="toto")
+@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")
 def test_copy_s3_file_nok(mock_hash_file, mock_makedirs, mocked_s3_client):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
-    s3_instance.download_file.side_effect = Exception('Cannot download S3 object')
+    s3_instance.download_file.side_effect = Exception("Cannot download S3 object")
     mocked_s3_client.return_value = s3_instance
 
     with pytest.raises(StorageError):
@@ -226,10 +277,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.upload_file.return_value = None
@@ -242,10 +296,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.copy.return_value = None
@@ -258,10 +315,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.copy.return_value = None
@@ -274,10 +334,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.copy.return_value = None
@@ -287,12 +350,16 @@ 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('rok4.Storage.rados.Rados')
-@mock.patch('os.makedirs', return_value=None)
+
+@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)
 def test_copy_ceph_file_ok(mock_file, mock_makedirs, mocked_rados_client):
-
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.read.return_value = b"data"
@@ -301,16 +368,24 @@ def test_copy_ceph_file_ok(mock_file, mock_makedirs, mocked_rados_client):
     mocked_rados_client.return_value = ceph_instance
 
     try:
-        copy("ceph://pool/source.ext", "file:///path/to/destination.ext", "8d777f385d3dfec8815d20f7496026dc")
+        copy(
+            "ceph://pool/source.ext",
+            "file:///path/to/destination.ext",
+            "8d777f385d3dfec8815d20f7496026dc",
+        )
         mock_makedirs.assert_called_once_with("/path/to", exist_ok=True)
     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('rok4.Storage.rados.Rados')
+
+@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):
-
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.write.return_value = None
@@ -319,15 +394,23 @@ def test_copy_file_ceph_ok(mock_file, mocked_rados_client):
     mocked_rados_client.return_value = ceph_instance
 
     try:
-        copy("file:///path/to/source.ext", "ceph://pool/destination.ext", "8d777f385d3dfec8815d20f7496026dc")
+        copy(
+            "file:///path/to/source.ext",
+            "ceph://pool/destination.ext",
+            "8d777f385d3dfec8815d20f7496026dc",
+        )
     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('rok4.Storage.rados.Rados')
+
+@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):
-
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.read.return_value = b"data"
@@ -337,17 +420,31 @@ def test_copy_ceph_ceph_ok(mock_file, mocked_rados_client):
     mocked_rados_client.return_value = ceph_instance
 
     try:
-        copy("ceph://pool1/source.ext", "ceph://pool2/destination.ext", "8d777f385d3dfec8815d20f7496026dc")
+        copy(
+            "ceph://pool1/source.ext",
+            "ceph://pool2/destination.ext",
+            "8d777f385d3dfec8815d20f7496026dc",
+        )
     except Exception as exc:
         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('rok4.Storage.rados.Rados')
-@mock.patch('rok4.Storage.boto3.client')
+@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")
 def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
-
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.read.return_value = b"data"
@@ -355,7 +452,6 @@ def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     ceph_instance.open_ioctx.return_value = ioctx_instance
     mocked_rados_client.return_value = ceph_instance
 
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.upload_file.return_value = None
@@ -363,24 +459,30 @@ def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     mocked_s3_client.return_value = s3_instance
 
     try:
-        copy("ceph://pool1/source.ext", "s3://bucket/destination.ext", "8d777f385d3dfec8815d20f7496026dc")
+        copy(
+            "ceph://pool1/source.ext",
+            "s3://bucket/destination.ext",
+            "8d777f385d3dfec8815d20f7496026dc",
+        )
     except Exception as exc:
         assert False, f"CEPH -> S3 copy raises an exception: {exc}"
 
 
-
 ############ link
 
+
 def test_link_type_nok():
     with pytest.raises(StorageError):
         link("ceph://pool1/target.ext", "file:///path/to/link.ext")
 
+
 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('os.symlink', return_value=None)
+@mock.patch("os.symlink", return_value=None)
 def test_link_file_ok(mock_link):
     try:
         link("file:///path/to/target.ext", "file:///path/to/link.ext")
@@ -390,7 +492,7 @@ def test_link_file_ok(mock_link):
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('os.link', return_value=None)
+@mock.patch("os.link", return_value=None)
 def test_hlink_file_ok(mock_link):
     try:
         link("file:///path/to/target.ext", "file:///path/to/link.ext", True)
@@ -398,10 +500,14 @@ 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('rok4.Storage.rados.Rados')
-def test_link_ceph_ok(mocked_rados_client):
 
+@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):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.write.return_value = None
@@ -415,10 +521,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.put_object.return_value = None
@@ -430,10 +539,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.put_object.return_value = None
@@ -442,10 +554,12 @@ def test_link_s3_nok(mocked_s3_client):
     with pytest.raises(StorageError):
         link("s3://bucket1@a/target.ext", "s3://bucket2@b/link.ext")
 
+
 ############ get_size
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('os.stat')
+@mock.patch("os.stat")
 def test_size_file_ok(mock_stat):
     mock_stat.return_value.st_size = 12
     try:
@@ -454,10 +568,14 @@ 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('rok4.Storage.rados.Rados')
-def test_size_ceph_ok(mocked_rados_client):
 
+@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):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.stat.return_value = (12, "date")
@@ -472,10 +590,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.head_object.return_value = {"ContentLength": 12}
@@ -490,8 +611,9 @@ def test_size_s3_ok(mocked_s3_client):
 
 ############ exists
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('os.path.exists', return_value=True)
+@mock.patch("os.path.exists", return_value=True)
 def test_exists_file_ok(mock_exists):
     try:
         assert exists("file:///path/to/file.ext")
@@ -504,10 +626,14 @@ 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('rok4.Storage.rados.Rados')
-def test_exists_ceph_ok(mocked_rados_client):
 
+@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):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.stat.return_value = None
@@ -527,10 +653,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.head_object.return_value = None
@@ -541,7 +670,9 @@ def test_exists_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"S3 exists raises an exception: {exc}"
 
-    s3_instance.head_object.side_effect = botocore.exceptions.ClientError(operation_name='InvalidKeyPair.Duplicate', error_response={"Error": {"Code": "404"}})
+    s3_instance.head_object.side_effect = botocore.exceptions.ClientError(
+        operation_name="InvalidKeyPair.Duplicate", error_response={"Error": {"Code": "404"}}
+    )
     try:
         assert not exists("s3://bucket/object.ext")
     except Exception as exc:
@@ -550,8 +681,9 @@ def test_exists_s3_ok(mocked_s3_client):
 
 ############ remove
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('os.remove')
+@mock.patch("os.remove")
 def test_remove_file_ok(mock_remove):
     mock_remove.return_value = None
     try:
@@ -565,10 +697,14 @@ 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('rok4.Storage.rados.Rados')
-def test_remove_ceph_ok(mocked_rados_client):
 
+@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):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
     ioctx_instance.remove_object.return_value = None
@@ -588,10 +724,13 @@ 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('rok4.Storage.boto3.client')
+@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):
-
     disconnect_s3_clients()
     s3_instance = MagicMock()
     s3_instance.delete_object.return_value = None
@@ -605,6 +744,7 @@ def test_remove_s3_ok(mocked_s3_client):
 
 ############ get_osgeo_path
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_get_osgeo_path_file_ok():
     try:
@@ -613,9 +753,13 @@ 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)
-def test_get_osgeo_path_s3_ok():
 
+@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:
diff --git a/tests/test_TileMatrixSet.py b/tests/test_TileMatrixSet.py
index 7f41688..4750f50 100644
--- a/tests/test_TileMatrixSet.py
+++ b/tests/test_TileMatrixSet.py
@@ -6,125 +6,195 @@
 from unittest.mock import *
 from unittest import mock
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_missing_env():
     with pytest.raises(MissingEnvironmentError):
         tms = TileMatrixSet("tms")
 
+
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', side_effect=StorageError('FILE', 'Not found'))
+@mock.patch("rok4.TileMatrixSet.get_data_str", side_effect=StorageError("FILE", "Not found"))
 def test_wrong_file(mocked_get_data_str):
     with pytest.raises(StorageError):
         tms = TileMatrixSet("tms")
 
+
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
+)
 def test_bad_json(mocked_get_data_str):
     with pytest.raises(FormatError) as exc:
         tms = TileMatrixSet("tms")
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
+
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"]}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"]}',
+)
 def test_missing_id(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
         tms = TileMatrixSet("tms")
     assert str(exc.value) == "Missing attribute 'id' in 'file:///path/to/tms.json'"
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
+
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM"}',
+)
 def test_missing_crs(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
         tms = TileMatrixSet("tms")
     assert str(exc.value) == "Missing attribute 'crs' in 'file:///path/to/tms.json'"
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
 
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"crs":"epsg:123456","orderedAxes":["X","Y"],"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"crs":"epsg:123456","orderedAxes":["X","Y"],"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM"}',
+)
 def test_wrong_crs(mocked_get_data_str):
     with pytest.raises(Exception) as exc:
         tms = TileMatrixSet("tms")
-    assert str(exc.value) == "Wrong attribute 'crs' ('epsg:123456') in 'file:///path/to/tms.json', not recognize by OSR"
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    assert (
+        str(exc.value)
+        == "Wrong attribute 'crs' ('epsg:123456') in 'file:///path/to/tms.json', not recognize by OSR"
+    )
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
+
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"crs":"epsg:4326","orderedAxes":["Lat","Lon"],"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"crs":"epsg:4326","orderedAxes":["Lat","Lon"],"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"id":"PM"}',
+)
 def test_wrong_axes_order(mocked_get_data_str):
     with pytest.raises(Exception) as exc:
         tms = TileMatrixSet("tms")
-    assert str(exc.value) == "TMS 'file:///path/to/tms.json' own invalid axes order : only X/Y or Lon/Lat are handled"
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    assert (
+        str(exc.value)
+        == "TMS 'file:///path/to/tms.json' own invalid axes order : only X/Y or Lon/Lat are handled"
+    )
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
+
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
+)
 def test_missing_levels(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
         tms = TileMatrixSet("tms")
     assert str(exc.value) == "Missing attribute 'tileMatrices' in 'file:///path/to/tms.json'"
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
+
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"tileMatrices":[],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"tileMatrices":[],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
+)
 def test_no_levels(mocked_get_data_str):
     with pytest.raises(Exception) as exc:
         tms = TileMatrixSet("tms")
     assert str(exc.value) == "TMS 'file:///path/to/tms.json' has no level"
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
+
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"tileMatrices":[{"tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM","crs":"EPSG:3857"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"tileMatrices":[{"tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM","crs":"EPSG:3857"}',
+)
 def test_wrong_level(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
         tms = TileMatrixSet("tms")
     assert str(exc.value) == "Missing attribute tileMatrices[].'id' in 'file:///path/to/tms.json'"
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
+
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"tileMatrices":[{"id":"level_0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"tileMatrices":[{"id":"level_0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
+)
 def test_wrong_level_id(mocked_get_data_str):
     with pytest.raises(Exception) as exc:
         tms = TileMatrixSet("tms")
 
-    assert str(exc.value) == "TMS file:///path/to/tms.json owns a level whom id contains an underscore (level_0)"
-    mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+    assert (
+        str(exc.value)
+        == "TMS file:///path/to/tms.json owns a level whom id contains an underscore (level_0)"
+    )
+    mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
+
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
+)
 def test_ok(mocked_get_data_str):
     try:
         tms = TileMatrixSet("tms")
         assert tms.get_level("0") is not None
         assert tms.get_level("4") is None
-        mocked_get_data_str.assert_called_once_with('file:///path/to/tms.json')
+        mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
     except Exception as exc:
         assert False, f"'TileMatrixSet creation raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"tileMatrices":[{"id":"17","cellSize":1.19432856695588,"matrixHeight":131072,"pointOfOrigin":[-20037508.3427892,20037508.3427892],"tileHeight":256,"tileWidth":256,"scaleDenominator":4265.45916769957,"matrixWidth":131072}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"tileMatrices":[{"id":"17","cellSize":1.19432856695588,"matrixHeight":131072,"pointOfOrigin":[-20037508.3427892,20037508.3427892],"tileHeight":256,"tileWidth":256,"scaleDenominator":4265.45916769957,"matrixWidth":131072}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
+)
 def test_pm_conversions(mocked_get_data_str):
     try:
         tms = TileMatrixSet("tms")
         tm = tms.get_level("17")
         assert tm.x_to_column(670654.2832369965) == 67729
         assert tm.y_to_row(5980575.503117723) == 45975
-        assert tm.tile_to_bbox(67728, 45975) == (670199.864004489, 5980433.093032133, 670505.6121176295, 5980738.841145273)
-        assert tm.bbox_to_tiles((670034.4267107458, 5980565.948489188,670649.5059227281, 5980936.190344945)) == (67727, 45974,67729, 45975)
+        assert tm.tile_to_bbox(67728, 45975) == (
+            670199.864004489,
+            5980433.093032133,
+            670505.6121176295,
+            5980738.841145273,
+        )
+        assert tm.bbox_to_tiles(
+            (670034.4267107458, 5980565.948489188, 670649.5059227281, 5980936.190344945)
+        ) == (67727, 45974, 67729, 45975)
         assert tm.point_to_indices(670654.2832369965, 5980575.503117723) == (67729, 45975, 124, 136)
     except Exception as exc:
         assert False, f"'TileMatrixSet creation raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch('rok4.TileMatrixSet.get_data_str', return_value='{"crs":"EPSG:4326","tileMatrices":[{"tileWidth":256,"scaleDenominator":1066.36480348451,"matrixWidth":524288,"cellSize":2.68220901489258e-06,"matrixHeight":262144,"pointOfOrigin":[-180,90],"tileHeight":256,"id":"18"}],"orderedAxes":["Lon","Lat"],"id":"4326"}')
+@mock.patch(
+    "rok4.TileMatrixSet.get_data_str",
+    return_value='{"crs":"EPSG:4326","tileMatrices":[{"tileWidth":256,"scaleDenominator":1066.36480348451,"matrixWidth":524288,"cellSize":2.68220901489258e-06,"matrixHeight":262144,"pointOfOrigin":[-180,90],"tileHeight":256,"id":"18"}],"orderedAxes":["Lon","Lat"],"id":"4326"}',
+)
 def test_4326_conversions(mocked_get_data_str):
     try:
         tms = TileMatrixSet("tms")
         tm = tms.get_level("18")
         assert tm.x_to_column(5) == 269425
         assert tm.y_to_row(45) == 65535
-        assert tm.tile_to_bbox(269425, 65535) == (44.99999999999997, 4.999465942382926, 45.000686645507784, 5.000152587890739)
-        assert tm.bbox_to_tiles((45,5,48,6)) == (269425,61166,270882,65535)
-        assert tm.point_to_indices(45,5) == (269425, 65535, 199, 255)
+        assert tm.tile_to_bbox(269425, 65535) == (
+            44.99999999999997,
+            4.999465942382926,
+            45.000686645507784,
+            5.000152587890739,
+        )
+        assert tm.bbox_to_tiles((45, 5, 48, 6)) == (269425, 61166, 270882, 65535)
+        assert tm.point_to_indices(45, 5) == (269425, 65535, 199, 255)
     except Exception as exc:
         assert False, f"'TileMatrixSet creation raises an exception: {exc}"
diff --git a/tests/test_Utils.py b/tests/test_Utils.py
index bc7acc9..cdba571 100644
--- a/tests/test_Utils.py
+++ b/tests/test_Utils.py
@@ -18,6 +18,7 @@ def test_srs_to_spatialreference_ignf_ok():
     except Exception as exc:
         assert False, f"SpatialReference creation raises an exception: {exc}"
 
+
 def test_srs_to_spatialreference_epsg_ok():
     try:
         sr = srs_to_spatialreference("EPSG:3857")
@@ -25,21 +26,25 @@ def test_srs_to_spatialreference_epsg_ok():
     except Exception as exc:
         assert False, f"SpatialReference creation raises an exception: {exc}"
 
+
 def test_srs_to_spatialreference_ignf_nok():
     with pytest.raises(Exception):
         sr = srs_to_spatialreference("IGNF:TOTO")
 
+
 def test_srs_to_spatialreference_epsg_nok():
     with pytest.raises(Exception):
         sr = srs_to_spatialreference("EPSG:123456")
 
+
 def test_bbox_to_geometry_ok():
     try:
-        geom = bbox_to_geometry((0,0,5,10))
+        geom = bbox_to_geometry((0, 0, 5, 10))
         assert geom.Area() == 50
     except Exception as exc:
         assert False, f"Geometry creation from bbox raises an exception: {exc}"
 
+
 def test_reproject_bbox_ok():
     try:
         bbox = reproject_bbox((-90, -180, 90, 180), "EPSG:4326", "EPSG:3857")
@@ -49,18 +54,19 @@ def test_reproject_bbox_ok():
     except Exception as exc:
         assert False, f"Bbox reprojection raises an exception: {exc}"
 
+
 def test_reproject_point_ok():
     try:
         sr_4326 = srs_to_spatialreference("EPSG:4326")
         sr_3857 = srs_to_spatialreference("EPSG:3857")
         sr_ignf = srs_to_spatialreference("IGNF:WGS84G")
-        x,y = reproject_point((43, 3), sr_4326, sr_3857)
+        x, y = reproject_point((43, 3), sr_4326, sr_3857)
 
         assert math.isclose(x, 333958.4723798207, rel_tol=1e-5)
         assert math.isclose(y, 5311971.846945471, rel_tol=1e-5)
 
-        x,y = reproject_point((43, 3), sr_4326, sr_ignf)
-        assert (x,y) == (3, 43)
+        x, y = reproject_point((43, 3), sr_4326, sr_ignf)
+        assert (x, y) == (3, 43)
 
         bbox = reproject_bbox((43, 3, 44, 4), "EPSG:4326", "IGNF:WGS84G")
         assert bbox[0] == 3
@@ -70,15 +76,13 @@ def test_reproject_point_ok():
 
 # Tests for the rok4.Utils.compute_bbox function.
 
+
 def test_compute_bbox_epsg_3857_ok():
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
         random.seed()
 
-        image_size = (
-            random.randint(1, 1000),
-            random.randint(1, 1000)
-        )
+        image_size = (random.randint(1, 1000), random.randint(1, 1000))
         mocked_datasource.RasterXSize = image_size[0]
         mocked_datasource.RasterYSize = image_size[1]
 
@@ -88,28 +92,27 @@ def test_compute_bbox_epsg_3857_ok():
             random.uniform(-10000, 10000),
             random.uniform(-10000000.0, 10000000.0),
             random.uniform(-10000, 10000),
-            random.uniform(-10000, 10000)
+            random.uniform(-10000, 10000),
         )
-        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+        mocked_datasource.GetGeoTransform = Mock(return_value=transform_tuple)
         mocked_spatial_ref = MagicMock(osr.SpatialReference)
-        mocked_spatial_ref.GetDataAxisToSRSAxisMapping = Mock(return_value = [1,2])
-        mocked_datasource.GetSpatialRef = Mock(return_value = mocked_spatial_ref)
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping = Mock(return_value=[1, 2])
+        mocked_datasource.GetSpatialRef = Mock(return_value=mocked_spatial_ref)
 
         x_range = (
             transform_tuple[0],
-            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+            transform_tuple[0]
+            + image_size[0] * transform_tuple[1]
+            + image_size[1] * transform_tuple[2],
         )
         y_range = (
             transform_tuple[3],
-            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+            transform_tuple[3]
+            + image_size[0] * transform_tuple[4]
+            + image_size[1] * transform_tuple[5],
         )
 
-        expected = (
-            min(x_range),
-            min(y_range),
-            max(x_range),
-            max(y_range)
-        )
+        expected = (min(x_range), min(y_range), max(x_range), max(y_range))
         result = compute_bbox(mocked_datasource)
         assert math.isclose(result[0], expected[0], rel_tol=1e-5)
         assert math.isclose(result[1], expected[1], rel_tol=1e-5)
@@ -126,10 +129,7 @@ def test_compute_bbox_epsg_4326_ok():
         mocked_datasource = MagicMock(gdal.Dataset)
         random.seed()
 
-        image_size = (
-            random.randint(1, 1000),
-            random.randint(1, 1000)
-        )
+        image_size = (random.randint(1, 1000), random.randint(1, 1000))
         mocked_datasource.RasterXSize = image_size[0]
         mocked_datasource.RasterYSize = image_size[1]
 
@@ -139,28 +139,27 @@ def test_compute_bbox_epsg_4326_ok():
             random.uniform(-10000, 10000),
             random.uniform(-10000000.0, 10000000.0),
             random.uniform(-10000, 10000),
-            random.uniform(-10000, 10000)
+            random.uniform(-10000, 10000),
         )
-        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
+        mocked_datasource.GetGeoTransform = Mock(return_value=transform_tuple)
         mocked_spatial_ref = MagicMock(osr.SpatialReference)
-        mocked_spatial_ref.GetDataAxisToSRSAxisMapping = Mock(return_value = [2,1])
-        mocked_datasource.GetSpatialRef = Mock(return_value = mocked_spatial_ref)
+        mocked_spatial_ref.GetDataAxisToSRSAxisMapping = Mock(return_value=[2, 1])
+        mocked_datasource.GetSpatialRef = Mock(return_value=mocked_spatial_ref)
 
         x_range = (
             transform_tuple[0],
-            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+            transform_tuple[0]
+            + image_size[0] * transform_tuple[1]
+            + image_size[1] * transform_tuple[2],
         )
         y_range = (
             transform_tuple[3],
-            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+            transform_tuple[3]
+            + image_size[0] * transform_tuple[4]
+            + image_size[1] * transform_tuple[5],
         )
 
-        expected = (
-            min(y_range),
-            min(x_range),
-            max(y_range),
-            max(x_range)
-        )
+        expected = (min(y_range), min(x_range), max(y_range), max(x_range))
         result = compute_bbox(mocked_datasource)
         assert math.isclose(result[0], expected[0], rel_tol=1e-5)
         assert math.isclose(result[1], expected[1], rel_tol=1e-5)
@@ -177,10 +176,7 @@ def test_compute_bbox_no_srs_ok():
         mocked_datasource = MagicMock(gdal.Dataset)
         random.seed()
 
-        image_size = (
-            random.randint(1, 1000),
-            random.randint(1, 1000)
-        )
+        image_size = (random.randint(1, 1000), random.randint(1, 1000))
         mocked_datasource.RasterXSize = image_size[0]
         mocked_datasource.RasterYSize = image_size[1]
 
@@ -190,26 +186,25 @@ def test_compute_bbox_no_srs_ok():
             random.uniform(-10000, 10000),
             random.uniform(-10000000.0, 10000000.0),
             random.uniform(-10000, 10000),
-            random.uniform(-10000, 10000)
+            random.uniform(-10000, 10000),
         )
-        mocked_datasource.GetGeoTransform = Mock(return_value = transform_tuple)
-        mocked_datasource.GetSpatialRef = Mock(return_value = None)
+        mocked_datasource.GetGeoTransform = Mock(return_value=transform_tuple)
+        mocked_datasource.GetSpatialRef = Mock(return_value=None)
 
         x_range = (
             transform_tuple[0],
-            transform_tuple[0] + image_size[0] * transform_tuple[1] + image_size[1] * transform_tuple[2]
+            transform_tuple[0]
+            + image_size[0] * transform_tuple[1]
+            + image_size[1] * transform_tuple[2],
         )
         y_range = (
             transform_tuple[3],
-            transform_tuple[3] + image_size[0] * transform_tuple[4] + image_size[1] * transform_tuple[5]
+            transform_tuple[3]
+            + image_size[0] * transform_tuple[4]
+            + image_size[1] * transform_tuple[5],
         )
 
-        expected = (
-            min(x_range),
-            min(y_range),
-            max(x_range),
-            max(y_range)
-        )
+        expected = (min(x_range), min(y_range), max(x_range), max(y_range))
         result = compute_bbox(mocked_datasource)
         assert math.isclose(result[0], expected[0], rel_tol=1e-5)
         assert math.isclose(result[1], expected[1], rel_tol=1e-5)
@@ -222,11 +217,14 @@ def test_compute_bbox_no_srs_ok():
 
 # Tests for the rok4.Utils.compute_format function.
 
-@mock.patch('rok4.Utils.gdal.Info')
-@mock.patch('rok4.Utils.gdal.GetColorInterpretationName', return_value="Palette")
-@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=8)
-@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Byte")
-def test_compute_format_bit_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+
+@mock.patch("rok4.Utils.gdal.Info")
+@mock.patch("rok4.Utils.gdal.GetColorInterpretationName", return_value="Palette")
+@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=8)
+@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="Byte")
+def test_compute_format_bit_ok(
+    mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
+):
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
 
@@ -249,11 +247,13 @@ def test_compute_format_bit_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, m
         assert False, f"Color format computation raises an exception: {exc}"
 
 
-@mock.patch('rok4.Utils.gdal.Info')
-@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
-@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=8)
-@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Byte")
-def test_compute_format_uint8_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+@mock.patch("rok4.Utils.gdal.Info")
+@mock.patch("rok4.Utils.gdal.GetColorInterpretationName")
+@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=8)
+@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="Byte")
+def test_compute_format_uint8_ok(
+    mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
+):
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
 
@@ -284,11 +284,13 @@ def test_compute_format_uint8_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize,
         assert False, f"Color format computation raises an exception: {exc}"
 
 
-@mock.patch('rok4.Utils.gdal.Info')
-@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
-@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=32)
-@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="Float32")
-def test_compute_format_float32_ok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+@mock.patch("rok4.Utils.gdal.Info")
+@mock.patch("rok4.Utils.gdal.GetColorInterpretationName")
+@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=32)
+@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="Float32")
+def test_compute_format_float32_ok(
+    mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
+):
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
 
@@ -319,11 +321,13 @@ def test_compute_format_float32_ok(mocked_GetDataTypeName, mocked_GetDataTypeSiz
         assert False, f"Color format computation raises an exception: {exc}"
 
 
-@mock.patch('rok4.Utils.gdal.Info')
-@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
-@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=16)
-@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="UInt16")
-def test_compute_format_unsupported_nok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+@mock.patch("rok4.Utils.gdal.Info")
+@mock.patch("rok4.Utils.gdal.GetColorInterpretationName")
+@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=16)
+@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="UInt16")
+def test_compute_format_unsupported_nok(
+    mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
+):
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
 
@@ -354,11 +358,13 @@ def test_compute_format_unsupported_nok(mocked_GetDataTypeName, mocked_GetDataTy
         assert False, f"Color format computation raises an exception: {exc}"
 
 
-@mock.patch('rok4.Utils.gdal.Info')
-@mock.patch('rok4.Utils.gdal.GetColorInterpretationName')
-@mock.patch('rok4.Utils.gdal.GetDataTypeSize', return_value=16)
-@mock.patch('rok4.Utils.gdal.GetDataTypeName', return_value="UInt16")
-def test_compute_format_no_band_nok(mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info):
+@mock.patch("rok4.Utils.gdal.Info")
+@mock.patch("rok4.Utils.gdal.GetColorInterpretationName")
+@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=16)
+@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="UInt16")
+def test_compute_format_no_band_nok(
+    mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
+):
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
 
diff --git a/tests/test_Vector.py b/tests/test_Vector.py
index d9f22fc..221f5e4 100644
--- a/tests/test_Vector.py
+++ b/tests/test_Vector.py
@@ -15,67 +15,115 @@ def test_missing_env():
     with pytest.raises(MissingEnvironmentError):
         vector = Vector.from_file("ceph:///ign_std/vector.shp")
 
-@mock.patch('rok4.Vector.copy', side_effect=StorageError('CEPH', 'Not found'))
+
+@mock.patch("rok4.Vector.copy", side_effect=StorageError("CEPH", "Not found"))
 def test_wrong_file(mocked_copy):
     with pytest.raises(StorageError):
         vector = Vector.from_file("ceph:///vector.geojson")
 
+
 def test_wrong_format():
     with pytest.raises(Exception) as exc:
         vector = Vector.from_file("ceph:///vector.tif")
     assert str(exc.value) == "This format of file cannot be loaded"
 
-@mock.patch('rok4.Vector.ogr.Open', return_value="not a shape")
+
+@mock.patch("rok4.Vector.ogr.Open", return_value="not a shape")
 def test_wrong_content(mocked_copy):
     with pytest.raises(Exception) as exc:
         vector = Vector.from_file("file:///vector.shp")
     assert str(exc.value) == "The content of file:///vector.shp cannot be read"
 
-@mock.patch('rok4.Vector.copy')
-@mock.patch('rok4.Vector.ogr.Open', return_value="not a shape")
+
+@mock.patch("rok4.Vector.copy")
+@mock.patch("rok4.Vector.ogr.Open", return_value="not a shape")
 def test_wrong_content_ceph(mocked_open, mocked_copy):
     with pytest.raises(Exception) as exc:
         vector = Vector.from_file("file:///vector.shp")
     assert str(exc.value) == "The content of file:///vector.shp cannot be read"
 
-def test_ok_csv1() :
-    try :
-        vector_csv1 = Vector.from_file("file://tests/fixtures/vector.csv" , csv={"delimiter":";", "column_x":"x", "column_y":"y"})
-        assert str(vector_csv1.layers) == "[('vector', 3, [('id', 'String'), ('x', 'String'), ('y', 'String')])]"
+
+def test_ok_csv1():
+    try:
+        vector_csv1 = Vector.from_file(
+            "file://tests/fixtures/vector.csv",
+            csv={"delimiter": ";", "column_x": "x", "column_y": "y"},
+        )
+        assert (
+            str(vector_csv1.layers)
+            == "[('vector', 3, [('id', 'String'), ('x', 'String'), ('y', 'String')])]"
+        )
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
-def test_ok_csv2() :
-    try :
-        vector_csv2 = Vector.from_file("file://tests/fixtures/vector2.csv" , csv={"delimiter":";", "column_wkt":"WKT"})
+
+def test_ok_csv2():
+    try:
+        vector_csv2 = Vector.from_file(
+            "file://tests/fixtures/vector2.csv", csv={"delimiter": ";", "column_wkt": "WKT"}
+        )
         assert str(vector_csv2.layers) == "[('vector2', 1, [('id', 'String'), ('WKT', 'String')])]"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
-def test_ok_geojson() :
-    try :
+
+def test_ok_geojson():
+    try:
         vector = Vector.from_file("file://tests/fixtures/vector.geojson")
-        assert str(vector.layers) == "[('vector', 1, [('id', 'String'), ('id_fantoir', 'String'), ('numero', 'Integer'), ('rep', 'String'), ('nom_voie', 'String'), ('code_postal', 'Integer'), ('code_insee', 'Integer'), ('nom_commune', 'String'), ('code_insee_ancienne_commune', 'String'), ('nom_ancienne_commune', 'String'), ('x', 'Real'), ('y', 'Real'), ('lon', 'Real'), ('lat', 'Real'), ('type_position', 'String'), ('alias', 'String'), ('nom_ld', 'String'), ('libelle_acheminement', 'String'), ('nom_afnor', 'String'), ('source_position', 'String'), ('source_nom_voie', 'String'), ('certification_commune', 'Integer'), ('cad_parcelles', 'String')])]"
+        assert (
+            str(vector.layers)
+            == "[('vector', 1, [('id', 'String'), ('id_fantoir', 'String'), ('numero', 'Integer'), ('rep', 'String'), ('nom_voie', 'String'), ('code_postal', 'Integer'), ('code_insee', 'Integer'), ('nom_commune', 'String'), ('code_insee_ancienne_commune', 'String'), ('nom_ancienne_commune', 'String'), ('x', 'Real'), ('y', 'Real'), ('lon', 'Real'), ('lat', 'Real'), ('type_position', 'String'), ('alias', 'String'), ('nom_ld', 'String'), ('libelle_acheminement', 'String'), ('nom_afnor', 'String'), ('source_position', 'String'), ('source_nom_voie', 'String'), ('certification_commune', 'Integer'), ('cad_parcelles', 'String')])]"
+        )
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
-def test_ok_gpkg() :
-    try :
+
+def test_ok_gpkg():
+    try:
         vector = Vector.from_file("file://tests/fixtures/vector.gpkg")
-        assert str(vector.layers) == "[('Table1', 2, [('id', 'String')]), ('Table2', 2, [('id', 'Integer'), ('nom', 'String')])]"
+        assert (
+            str(vector.layers)
+            == "[('Table1', 2, [('id', 'String')]), ('Table2', 2, [('id', 'Integer'), ('nom', 'String')])]"
+        )
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
-def test_ok_shp() :
-    try :
+
+def test_ok_shp():
+    try:
         vector = Vector.from_file("file://tests/fixtures/ARRONDISSEMENT.shp")
-        assert str(vector.layers) == "[('ARRONDISSEMENT', 14, [('ID', 'String'), ('NOM', 'String'), ('INSEE_ARR', 'String'), ('INSEE_DEP', 'String'), ('INSEE_REG', 'String'), ('ID_AUT_ADM', 'String'), ('DATE_CREAT', 'String'), ('DATE_MAJ', 'String'), ('DATE_APP', 'Date'), ('DATE_CONF', 'Date')])]"
+        assert (
+            str(vector.layers)
+            == "[('ARRONDISSEMENT', 14, [('ID', 'String'), ('NOM', 'String'), ('INSEE_ARR', 'String'), ('INSEE_DEP', 'String'), ('INSEE_REG', 'String'), ('ID_AUT_ADM', 'String'), ('DATE_CREAT', 'String'), ('DATE_MAJ', 'String'), ('DATE_APP', 'Date'), ('DATE_CONF', 'Date')])]"
+        )
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"
 
-def test_ok_parameters() :
-    try :
-        vector = Vector.from_parameters("file://tests/fixtures/ARRONDISSEMENT.shp", (1,2,3,4), [('ARRONDISSEMENT', 14, [('ID', 'String'), ('NOM', 'String'), ('INSEE_ARR', 'String'), ('INSEE_DEP', 'String'), ('INSEE_REG', 'String'), ('ID_AUT_ADM', 'String'), ('DATE_CREAT', 'String'), ('DATE_MAJ', 'String'), ('DATE_APP', 'Date'), ('DATE_CONF', 'Date')])])
+
+def test_ok_parameters():
+    try:
+        vector = Vector.from_parameters(
+            "file://tests/fixtures/ARRONDISSEMENT.shp",
+            (1, 2, 3, 4),
+            [
+                (
+                    "ARRONDISSEMENT",
+                    14,
+                    [
+                        ("ID", "String"),
+                        ("NOM", "String"),
+                        ("INSEE_ARR", "String"),
+                        ("INSEE_DEP", "String"),
+                        ("INSEE_REG", "String"),
+                        ("ID_AUT_ADM", "String"),
+                        ("DATE_CREAT", "String"),
+                        ("DATE_MAJ", "String"),
+                        ("DATE_APP", "Date"),
+                        ("DATE_CONF", "Date"),
+                    ],
+                )
+            ],
+        )
         assert str(vector.path) == "file://tests/fixtures/ARRONDISSEMENT.shp"
     except Exception as exc:
         assert False, f"Vector creation raises an exception: {exc}"

From 336a9715eca97b3f6ba3863c86caa7bfc1b2c73d Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Mon, 5 Jun 2023 17:34:27 +0200
Subject: [PATCH 50/89] Add PR autolabeler

---
 .github/labeler.yml                   | 21 +++++++++++++++++++++
 .github/workflows/pr-auto-labeler.yml | 15 +++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 .github/labeler.yml
 create mode 100644 .github/workflows/pr-auto-labeler.yml

diff --git a/.github/labeler.yml b/.github/labeler.yml
new file mode 100644
index 0000000..75c5ceb
--- /dev/null
+++ b/.github/labeler.yml
@@ -0,0 +1,21 @@
+ci-cd:
+  - .github/**/*
+
+dependencies:
+  - requirements.txt
+  - requirements/*.txt
+
+documentation:
+  - docs/**/*
+
+enhancement:
+  - src/**/*
+
+quality:
+  - tests/**/*
+
+tooling:
+  - .gitignore
+  - .pre-commit-config.yaml
+  - setup.cfg
+  - pyproject.toml
diff --git a/.github/workflows/pr-auto-labeler.yml b/.github/workflows/pr-auto-labeler.yml
new file mode 100644
index 0000000..42ec571
--- /dev/null
+++ b/.github/workflows/pr-auto-labeler.yml
@@ -0,0 +1,15 @@
+name: "🏷 PR Labeler"
+on:
+  - pull_request_target
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v4
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"

From f8766f964ac4c909faf5d73b753266d2bd775b59 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Mon, 5 Jun 2023 17:34:40 +0200
Subject: [PATCH 51/89] Add config for auto release notes

---
 .github/release.yml | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 .github/release.yml

diff --git a/.github/release.yml b/.github/release.yml
new file mode 100644
index 0000000..c879bf9
--- /dev/null
+++ b/.github/release.yml
@@ -0,0 +1,24 @@
+changelog:
+  exclude:
+    authors:
+      - dependabot
+      - pre-commit-ci
+  categories:
+    - title: Correction de bugs 🐛
+      labels:
+        - bug
+    - title: Améliorations et nouvelles fonctionnalités 🎉
+      labels:
+        - enhancement
+        - quality
+    - title: Outillage 🔧
+      labels:
+        - ci-cd
+        - dependencies
+        - tooling
+    - title: Documentation 📖
+      labels:
+        - documentation
+    - title: Divers
+      labels:
+        - "*"

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 52/89] 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')

From e7a8c5117873409ce8b0cdad7ebcee4b829470e6 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 7 Jul 2023 17:06:48 +0200
Subject: [PATCH 53/89] Nouvelle gestion du changelog

Le fichier contient toutes les versions avec leurs modifications
---
 .github/workflows/build-and-release.yaml |  11 +-
 CHANGELOG.md                             | 143 +++++++++++++++++++++--
 CONTRIBUTING.md                          |  12 +-
 3 files changed, 148 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index b5cc6e6..835b3fb 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -19,13 +19,12 @@ jobs:
 
       - name: Create Release
         id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        uses: ncipollo/release-action@v1
         with:
-          tag_name: ${{ github.ref_name }}
-          release_name: Release ${{ github.ref_name }}
-          body_path: CHANGELOG.md
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ github.ref_name }}
+          name: Release ${{ github.ref_name }}
+          generateReleaseNotes: true
           draft: false
           prerelease: false
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c971dda..0474158 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,17 +1,146 @@
-## Summary
 
-## Changelog
+## 1.6.0
+
+Lecture par système de fichier virtuel avec GDAL
 
-<!--
 ### [Added]
 
+* Storage
+    * Fonction `get_osgeo_path` permettant de configurer le bon sytème de fichier virtuel en fonction du chemin fourni, et retourne celui à utiliser dans le Open de gdal ou ogr
+
 ### [Changed]
 
-### [Deprecated]
+* Storage
+    * la récupération d'un client S3 (`__get_s3_client`) permet de récupérer le client, l'hôte, les clés d'accès et secrète, ainsi que le nom du bucket sans l'éventuel hôte du cluster
+
+### [Fixed]
+
+* Storage
+    * Lecture binaire S3 : mauvaise configuration du nom du bucket et de l'objet et mauvaise lecture partielle
 
 ### [Removed]
 
-### [Fixed]
+* Exceptions
+    * `NotImplementedError` est une exceptions native
+
+
+## 1.5.0
+
+### [Added]
+
+* Level
+    * Fonction de test d'une tuile `is_in_limits` : ses indices sont ils dans les limites du niveau ?
+* Pyramid
+    * La lecture d'une tuile vérifie avant que les indices sont bien dans les limites du niveau
+    * Les exceptions levées lors du décodage de la tuile raster emettent une exception `FormatError`
+    * `get_tile_indices` accepte en entrée un système de coordonnées : c'est celui des coordonnées fournies et permet de faire une reprojection si celui ci n'est pas le même que celui des données dans la pyramide
+* Utils
+    * Meilleure gestion de reprojection par `reproject_bbox` : on détecte des systèmes identiques en entrée ou quand seul l'ordre des axes changent, pour éviter le calcul
+    * Ajout de la fonction de reprojection d'un point `reproject_point` : on détecte des systèmes identiques en entrée ou quand seul l'ordre des axes changent, pour éviter le calcul
+  
+### [Changed]
+
+* Utils :
+    * `bbox_to_geometry` : on ne fournit plus de système de coordonnées, la fonction se content de créer la géométrie OGR à partir de la bbox, avec éventuellement une densification en points des bords
+* Pyramid :
+    * Renommage de fonction : `update_limits` -> `set_limits_from_bbox`. Le but est d'être plus explicite sur le fonctionnement de la fonction (on écrase les limites, on ne les met pas juste à jour par union avec la bbox fournie)
+
+
+## 1.4.4
+
+Ajout de fonctionnalités de lecture de donnée d'une pyramide et suivi des recommandations PyPA pour la gestion du projet.
+
+### [Added]
+
+* TileMatrix :
+    * Fonction de calcul des indices de tuile et de pixel dans la tuile à partir d'un point dans le système de coordonnées du TMS
+* Pyramid :
+    * Fonction de calcul des indices de tuile et de pixel dans la tuile à partir d'un point dans le système de coordonnées du TMS et éventuellement un niveau
+    * Fonctions de lecture d'une tuile : au format binaire source ou au format tableau à 3 dimensions pour les tuiles raster
+* Storage :
+    * Fonction de lecture binaire, complète ou partielle, d'un fichier ou objet S3 ou CEPH
+* Exceptions : NotImplementedError permet de préciser qu'une fonctionnalité n'a pas été implémentée pour tous les cas. Ici, on ne gère pas la décompression des données raster pour les compressions packbit et LZW
+  
+* Ajout de la publication PyPI dans la CI GitHub 
+
+### [Changed]
+
+* Storage :
+    * La lecture sous forme de chaîne s'appuie sur la lecture complète binaire. Aucun changement à l'usage.
+* TileMatrixSet : quelque soit le système de coordonnées, on ne gère que un ordre des axes X,Y ou Lon,Lat. Cependant, les fonctions de calcul de ou à partir de bbox respectent l'ordre du système dans ces dernières.
+
+* Passage de la configuration du projet dans le fichier `pyproject.toml`
+
+
+## 1.3.0
+
+Ajout de la librairie de lecture de données vecteur, de tests unitaires et ajout de fonctionnalité pour le stockage. Amélioration de la gestion du projet et de l'intégration continue.
+
+### [Added]
+
+* Librairie de lecture de données vecteur :
+  * Chargement de données vecteur pour des fichiers shapefile, Geopackage, CSV et GeoJSON
+  * Ecriture des tests unitaires
+* Librairie Pyramid : complétion des tests unitaires
+* Librairie Storage : prise en charge de la copie CEPH -> S3
+* Gestion du projet (compilations, dépendances...) via poetry
+* Injection de la version dans le fichier `pyproject.toml` et `__init__.py` (définition de la variable `__version__`)
+* Évolution de la CI github
+    * Vérification des installations et tests unitaires sous ubuntu 20.04 python 3.8 et ubuntu 22.04 python 3.10
+    * Publication de l'artefact avec les résultats des tests unitaires
+    * Nettoyage de la release en cas d'erreur
+    * Compilation de la documentation et publication sur la branche gh-pages
+
+
+## 1.2.0
+
+Ajout des librairies pour l'utilitaire make-layer.py
+
+### [Added]
+
+* Librairie Storage : complétion des tests unitaires
+
+* Librairie Pyramid :
+  * Ajout de getter sur les niveaux du haut et du bas
+
+* Ajout de la librairie de gestion d'une couche Layer :
+  * Chargement d'une couche depuis des paramètres
+  * Chargement d'une couche depuis un descripteur
+  * Écriture du descripteur au format attendu par le serveur
+  * Écriture des tests unitaires
+
+* Ajout d'une librairie d'utilitaires Utils
+  * Conversion d'un SRS en objet OSR SpatialReference
+  * Conversion d'une bbox en objet OGR Geometry
+  * Reprojection d'une bbox avec densification des côtés et reprojection partielle
+  * Écriture des tests unitaires
+
+* Configuration de l'outil coverage pour voir la couverture des tests unitaires
+
+
+## 1.1.0
+
+Prise en charge de plusieurs clusters S3 de stockage.
+
+### [Added]
+
+* Librairie d'abstraction du stockage :
+  * Prise en charge de plusieurs clusters S3. Les variables d'environnement pour le stockage S3 précisent plusieurs valeurs séparées par des virgules, et les noms des buckets peuvent être suffixés par "@{S3 cluster host}". Par défaut, le premier cluster défini est utilisé. L'hôte du cluster n'est jamais écrit dans le descripteur de pyramide ou le fichier liste (puisque stockés sur le cluster, on sait sur lequel sont les objets). Les objets symboliques ne le précisent pas non plus et ne peuvent être qu'au sein d'un cluster S3
+
+
+## 1.0.0
+
+Initialisation des librairies Python utilisées par les outils python à venir du dépôt [pytools](https://github.com/rok4/pytools).
+
+### [Added]
 
-### [Security]
--->
+* Librairie d'abstraction du stockage (S3, CEPH ou FILE)
+  * récupération du contenu sous forme de string
+  * écriture d'un contenu string
+  * création d'un lien symbolique
+  * copie fichier/objet <-> fichier/objet
+* Librairie de chargement d'un Tile Matrix Set
+* Librairie de gestion d'un descripteur de pyramide
+  * chargement depuis un descripteur ou par clone (avec changement de stockage)
+  * écriture du descripteur
+* Tests unitaires couvrant ces librairies
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index caa2d20..568d889 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,8 +1,6 @@
 # Directives de contribution
 
-Tout d'abord, merci d'envisager de contribuer à ce projet !
-
-Il s'agit principalement de lignes directrices, et non de règles. Faites preuve de discernement, et n'hésitez pas à proposer des modifications à ce document dans une pull request.
+Merci d'envisager de contribuer à ce projet !
 
 ## Git hooks
 
@@ -10,11 +8,13 @@ Nous utilisons les git hooks via [pre-commit](https://pre-commit.com/) pour appl
 
 Voir le fichier de configuration correspondant : `.pre-commit-config.yaml`.
 
-## CHANGELOG
+## Changelog
 
 Pour éviter les conflits d'édition du changelog en cas de multiples contributions parallèles, n'éditez pas directement le fichier `CHANGELOG.md` sur votre branche de travail.
+
 A la place, indiquez en description ou commentaire de votre pull request, bien en évidence, le changelog qui concerne spécifiquement cette PR, avec le même formalisme que le fichier `CHANGELOG.md`.
-Le mainteneur qui validera la PR éditera alors ce fichier dans le même temps, avec deux objectifs :
+
+Lors de la release de la prochaine version, le mainteneur ajoutera vos notes de modifications dans le fichier `CHANGELOG.md` ce fichier dans le même temps, avec deux objectifs :
 
 * la date de modification sera celle de la fusion de branches.
 * le contenu pourra tenir compte de toutes les modifications depuis la dernière release.
@@ -22,6 +22,8 @@ Le mainteneur qui validera la PR éditera alors ce fichier dans le même temps,
 Le formalisme du changelog est le suivant, en markdown :
 
 ```md
+Résumé des objectifs des modifications apportées
+
 ### [Added]
 
 Liste de nouvelles fonctionnalités.

From 757d4e5fd04bbc06f855dc929b9c2f5d55255a03 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Mon, 10 Jul 2023 14:27:57 +0200
Subject: [PATCH 54/89] =?UTF-8?q?Pr=C3=A9paration=20=C3=A0=20la=20publicat?=
 =?UTF-8?q?ion=20de=20la=201.7.1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Complétion du Changelog
* Adaptation aux changements du site de documentation
---
 .github/workflows/build-and-release.yaml | 25 ++++++++--------
 CHANGELOG.md                             | 38 ++++++++++++++++++++++++
 CONTRIBUTING.md                          | 13 ++------
 README.md                                |  6 +---
 pyproject.toml                           |  2 +-
 5 files changed, 55 insertions(+), 29 deletions(-)

diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 835b3fb..5f3767f 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -182,17 +182,18 @@ jobs:
 
       - name: Add pages from templates
         run: |
-          sed "s#__version__#${{ github.ref_name }}#" templates/TESTS.template.md >docs/versions/${{ github.ref_name }}/TESTS.md
-          sed "s#__version__#${{ github.ref_name }}#" templates/DOCUMENTATION.template.md >docs/versions/${{ github.ref_name }}/DOCUMENTATION.md
-          sed "s#__version__#${{ github.ref_name }}#" templates/CHANGELOG.template.md >docs/versions/${{ github.ref_name }}/CHANGELOG.md
-          cat artifact/CHANGELOG.md >>docs/versions/${{ github.ref_name }}/CHANGELOG.md
-          sed "s#__version__#${{ github.ref_name }}#" templates/README.template.md >docs/versions/${{ github.ref_name }}/README.md
-          cat artifact/README.md >>docs/versions/${{ github.ref_name }}/README.md
-          sed -i "s#x.y.z#${{ github.ref_name }}#g" docs/versions/${{ github.ref_name }}/README.md
-          sed "s#__version__#${{ github.ref_name }}#" templates/index.template.md >docs/index.md
-          echo "# Versions" >docs/versions.md
-          echo "" >>docs/versions.md
-          for v in `ls -t docs/versions | grep -v latest`; do sed "s#__version__#$v#" templates/versions.template.md >>docs/versions.md; done
+          sed "s#__version__#${{ github.ref_name }}#" templates/mkdocs.template.yml >mkdocs.yml
+
+          sed "s#__version__#${{ github.ref_name }}#" templates/tests.template.md >docs/versions/${{ github.ref_name }}/tests.md
+          sed "s#__version__#${{ github.ref_name }}#" templates/documentation.template.md >docs/versions/${{ github.ref_name }}/documentation.md
+
+          sed "s#__version__#${{ github.ref_name }}#" templates/index-version.template.md >docs/versions/${{ github.ref_name }}/index.md
+          cat artifact/README.md >>docs/versions/${{ github.ref_name }}/index.md
+          sed -i "s#x.y.z#${{ github.ref_name }}#g" docs/versions/${{ github.ref_name }}/index.md
+
+          cp templates/index-versions.template.md docs/versions/index.md
+          sed "s/^## \(.*\)$/## \1 \n\n[➔ Lien vers la documentation](\1\/index.md) /" artifact/CHANGELOG.md >>docs/versions/index.md
+
           sed "s#__version__#${{ github.ref_name }}#" templates/latest.template.html >docs/versions/latest/index.html
           rm -r artifact
 
@@ -200,7 +201,7 @@ jobs:
         run: |
           git config user.name github-actions
           git config user.email github-actions@github.com
-          git add -v docs/versions/${{ github.ref_name }}/ docs/versions/latest/ docs/index.md docs/versions.md
+          git add -v docs/versions/${{ github.ref_name }}/ docs/versions/latest/ docs/versions/index.md mkdocs.yml
           git commit -m "Add documentation for version ${{ github.ref_name }}"
           git push
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0474158..be082c3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,41 @@
+## 1.7.1
+
+### [Added]
+
+* Raster
+    * Classe RasterSet, réprésentant une collection d'objets de la classe Raster, avec des informations supplémentaires
+    * Méthodes d'import et export des informations extraites par une instance RasterSet, au travers d'un descripteur (fichier ou objet json, voire sortie standard)
+    * Documentation interne
+    * Tests unitaires pour la classe RasterSet
+    * Classe Raster : constructeur à partir des paramètres
+  
+* Pyramid
+    * Fonction de calcul de la taille d'une pyramide
+    * Générateur de lecture de la liste du contenu
+
+* Storage
+    * Fonction de calcul de la taille des fichiers d'un chemin selon le stockage
+    * Ajout de la copie de HTTP vers FILE/S3/CEPH
+    * Ajout de la fonction de lecture d'un fichier HTTP, de l'existence d'un fichier HTTP et du calcul de taille d'un fichier HTTP
+
+### [Changed]
+
+* Raster
+    * Homogénéisation du code
+    * Mise en conformité PEP-8
+* test_Raster
+    * Homogénéisation du code
+    * Mise en conformité PEP-8
+* Utils
+    * Mise en conformité PEP-8 des fonctions `compute_bbox` et `compute_format`
+
+
+### [Fixed]
+
+* Utils
+    * Correction d'un nom de variable dans la fonction `compute_format`, qui écrasait une fonction du noyau python.
+
+
 
 ## 1.6.0
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 568d889..ff54d46 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -8,22 +8,13 @@ Nous utilisons les git hooks via [pre-commit](https://pre-commit.com/) pour appl
 
 Voir le fichier de configuration correspondant : `.pre-commit-config.yaml`.
 
-## Changelog
+## Pull request
 
-Pour éviter les conflits d'édition du changelog en cas de multiples contributions parallèles, n'éditez pas directement le fichier `CHANGELOG.md` sur votre branche de travail.
-
-A la place, indiquez en description ou commentaire de votre pull request, bien en évidence, le changelog qui concerne spécifiquement cette PR, avec le même formalisme que le fichier `CHANGELOG.md`.
-
-Lors de la release de la prochaine version, le mainteneur ajoutera vos notes de modifications dans le fichier `CHANGELOG.md` ce fichier dans le même temps, avec deux objectifs :
-
-* la date de modification sera celle de la fusion de branches.
-* le contenu pourra tenir compte de toutes les modifications depuis la dernière release.
+Le titre de la PR est utilisé pour constituer automatiquement les notes de release. Vous pouvez préciser en commentaire de votre PR des détails qui seront ajoutés dans le fichier `CHANGELOG.md` par les mainteneurs du projet.
 
 Le formalisme du changelog est le suivant, en markdown :
 
 ```md
-Résumé des objectifs des modifications apportées
-
 ### [Added]
 
 Liste de nouvelles fonctionnalités.
diff --git a/README.md b/README.md
index b4399ba..29bf082 100644
--- a/README.md
+++ b/README.md
@@ -4,11 +4,6 @@
 
 Ces librairies facilitent la manipulation d'entités du projet ROK4 comme les Tile Matrix Sets, les pyramides ou encore les couches, ainsi que la manipulation des stockages associés.
 
-- [Installer la librairie](#installer-la-librairie)
-- [Utiliser la librairie](#utiliser-la-librairie)
-- [Compiler la librairie](#compiler-la-librairie)
-- [Publier la librairie sur Pypi](#publier-la-librairie-sur-pypi)
-
 ## Installer la librairie
 
 Installations système requises :
@@ -73,6 +68,7 @@ python3 -m build
 ```
 
 Remarque :
+
 Lors de l'installation du paquet apt `python3-gdal`, une dépendance, peut demander des interactions de configuration. Pour installer dans un environnement non-interactif, définir la variable shell `DEBIAN_FRONTEND=noninteractive` permet d'adopter une configuration par défaut.
 
 ## Publier la librairie sur Pypi
diff --git a/pyproject.toml b/pyproject.toml
index 9f58bdd..4e1599b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -55,7 +55,7 @@ test = [
 [project.urls]
 "Homepage" = "https://rok4.github.io/core-python"
 "Bug Reports" = "https://github.com/rok4/core-python/issues"
-"Changelog" = "https://github.com/rok4/core-python/releases"
+"Changelog" = "https://rok4.github.io/core-python/versions/"
 "Source" = "https://github.com/rok4/core-python"
 
 [build-system]

From ecd969ebbfe759a88586bab75019a902e0d652f9 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Tue, 11 Jul 2023 11:10:56 +0200
Subject: [PATCH 55/89] Correction de la page des tests unitaires

---
 .github/workflows/build-and-release.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 5f3767f..8fb0b1e 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -184,7 +184,7 @@ jobs:
         run: |
           sed "s#__version__#${{ github.ref_name }}#" templates/mkdocs.template.yml >mkdocs.yml
 
-          sed "s#__version__#${{ github.ref_name }}#" templates/tests.template.md >docs/versions/${{ github.ref_name }}/tests.md
+          sed "s#__version__#${{ github.ref_name }}#" templates/unit-tests.template.md >docs/versions/${{ github.ref_name }}/unit-tests.md
           sed "s#__version__#${{ github.ref_name }}#" templates/documentation.template.md >docs/versions/${{ github.ref_name }}/documentation.md
 
           sed "s#__version__#${{ github.ref_name }}#" templates/index-version.template.md >docs/versions/${{ github.ref_name }}/index.md

From f5f8a98dcce311bfb9527405dae8cd8c5fc7f67e Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 12:34:29 +0200
Subject: [PATCH 56/89] Add isort as git hook

---
 .pre-commit-config.yaml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 31a1cee..033c0cd 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -25,3 +25,9 @@ repos:
     rev: 23.3.0
     hooks:
       - id: black
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        args: ["--profile", "black", "--filter-files"]

From 17d1d39682e22fe0169f67873d2489c6aa836ade Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 12:37:48 +0200
Subject: [PATCH 57/89] Add isort to dev dependencies

---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index 4e1599b..f172c36 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -44,6 +44,7 @@ doc = [
 
 dev = [
   "black",
+  "isort >= 5.12.0",
   "pre-commit >3,<4"
 ]
 

From 91b0d3d05a3827dd5c2d2e436a66e1675d48e1af Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 12:41:43 +0200
Subject: [PATCH 58/89] Apply isort

---
 CHANGELOG.md                |  10 +--
 src/rok4/Layer.py           |   6 +-
 src/rok4/Pyramid.py         |  31 ++++-----
 src/rok4/Raster.py          |   4 +-
 src/rok4/Storage.py         |  98 +++++++++++++++-------------
 src/rok4/TileMatrixSet.py   |  10 +--
 src/rok4/Utils.py           |   6 +-
 src/rok4/Vector.py          |   8 ++-
 tests/test_Layer.py         |  12 ++--
 tests/test_Pyramid.py       |  15 +++--
 tests/test_Raster.py        |   8 +--
 tests/test_Storage.py       | 124 ++++++++++++++++++++++++------------
 tests/test_TileMatrixSet.py |  11 ++--
 tests/test_Utils.py         |  14 ++--
 tests/test_Vector.py        |  13 ++--
 15 files changed, 211 insertions(+), 159 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index be082c3..24eaed0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,7 +8,7 @@
     * Documentation interne
     * Tests unitaires pour la classe RasterSet
     * Classe Raster : constructeur à partir des paramètres
-  
+
 * Pyramid
     * Fonction de calcul de la taille d'une pyramide
     * Générateur de lecture de la liste du contenu
@@ -75,7 +75,7 @@ Lecture par système de fichier virtuel avec GDAL
 * Utils
     * Meilleure gestion de reprojection par `reproject_bbox` : on détecte des systèmes identiques en entrée ou quand seul l'ordre des axes changent, pour éviter le calcul
     * Ajout de la fonction de reprojection d'un point `reproject_point` : on détecte des systèmes identiques en entrée ou quand seul l'ordre des axes changent, pour éviter le calcul
-  
+
 ### [Changed]
 
 * Utils :
@@ -98,8 +98,8 @@ Ajout de fonctionnalités de lecture de donnée d'une pyramide et suivi des reco
 * Storage :
     * Fonction de lecture binaire, complète ou partielle, d'un fichier ou objet S3 ou CEPH
 * Exceptions : NotImplementedError permet de préciser qu'une fonctionnalité n'a pas été implémentée pour tous les cas. Ici, on ne gère pas la décompression des données raster pour les compressions packbit et LZW
-  
-* Ajout de la publication PyPI dans la CI GitHub 
+
+* Ajout de la publication PyPI dans la CI GitHub
 
 ### [Changed]
 
@@ -181,4 +181,4 @@ Initialisation des librairies Python utilisées par les outils python à venir d
 * Librairie de gestion d'un descripteur de pyramide
   * chargement depuis un descripteur ou par clone (avec changement de stockage)
   * écriture du descripteur
-* Tests unitaires couvrant ces librairies
\ No newline at end of file
+* Tests unitaires couvrant ces librairies
diff --git a/src/rok4/Layer.py b/src/rok4/Layer.py
index 316a9ca..74387ae 100644
--- a/src/rok4/Layer.py
+++ b/src/rok4/Layer.py
@@ -5,16 +5,16 @@
 - `Layer` - Descriptor to broadcast pyramids' data
 """
 
-from typing import Dict, List, Tuple, Union
 import json
-from json.decoder import JSONDecodeError
 import os
 import re
+from json.decoder import JSONDecodeError
+from typing import Dict, List, Tuple, Union
 
 from rok4.Exceptions import *
 from rok4.Pyramid import Pyramid, PyramidType
-from rok4.TileMatrixSet import TileMatrixSet
 from rok4.Storage import *
+from rok4.TileMatrixSet import TileMatrixSet
 from rok4.Utils import *
 
 
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 7667244..a16465a 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -6,20 +6,21 @@
 - `Level` - Level of a pyramid
 """
 
-from typing import Dict, List, Tuple, Union, Iterator
+import io
 import json
-from json.decoder import JSONDecodeError
 import os
 import re
-import numpy
 import zlib
-import io
+from json.decoder import JSONDecodeError
+from typing import Dict, Iterator, List, Tuple, Union
+
 import mapbox_vector_tile
+import numpy
 from PIL import Image
 
 from rok4.Exceptions import *
-from rok4.TileMatrixSet import TileMatrixSet, TileMatrix
 from rok4.Storage import *
+from rok4.TileMatrixSet import TileMatrix, TileMatrixSet
 from rok4.Utils import *
 
 
@@ -549,11 +550,8 @@ def serializable(self) -> Dict:
         Returns:
             Dict: descriptor structured object description
         """
-        
-        serialization = {
-            "tile_matrix_set": self.__tms.name,
-            "format": self.__format
-        }
+
+        serialization = {"tile_matrix_set": self.__tms.name, "format": self.__format}
 
         serialization["levels"] = []
         sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
@@ -620,7 +618,7 @@ def storage_root(self) -> str:
         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
@@ -670,7 +668,6 @@ def format(self) -> str:
 
     @property
     def tile_extension(self) -> str:
-
         if self.__format in [
             "TIFF_RAW_UINT8",
             "TIFF_LZW_UINT8",
@@ -835,7 +832,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)
 
     def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
@@ -1019,7 +1016,6 @@ def get_slab_path_from_infos(
         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
 
@@ -1182,7 +1178,6 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
         level_object = self.get_level(level)
 
         if self.__format == "TIFF_JPG_UINT8" or self.__format == "TIFF_JPG90_UINT8":
-
             try:
                 img = Image.open(io.BytesIO(binary_tile))
             except Exception as e:
@@ -1379,6 +1374,8 @@ def size(self) -> int:
         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))
+        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/Raster.py b/src/rok4/Raster.py
index 640f4bf..271fc6a 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/Raster.py
@@ -10,9 +10,9 @@
 import json
 import re
 from enum import Enum
-from typing import Tuple, Dict
+from typing import Dict, Tuple
 
-from osgeo import ogr, gdal
+from osgeo import gdal, ogr
 
 from rok4.Storage import exists, get_osgeo_path, put_data_str
 from rok4.Utils import ColorFormat, compute_bbox, compute_format
diff --git a/src/rok4/Storage.py b/src/rok4/Storage.py
index bcbee52..66e3d6d 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -30,17 +30,18 @@
 To precise the cluster to use, bucket name should be bucket_name@s3.storage.fr or bucket_name@s4.storage.fr. If no host is defined (no @) in the bucket name, first S3 cluster is used
 """
 
+import hashlib
+import os
+import re
+import tempfile
+from enum import Enum
+from shutil import copyfile
+from typing import Dict, List, Tuple, Union
+
 import boto3
 import botocore.exceptions
-import tempfile
-import re
-import os
 import rados
-import hashlib
 import requests
-from typing import Dict, List, Tuple, Union
-from enum import Enum
-from shutil import copyfile
 from osgeo import gdal
 
 gdal.UseExceptions()
@@ -75,7 +76,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
     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:
@@ -134,7 +135,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
 
 def disconnect_s3_clients() -> None:
     """Clean S3 clients"""
-  
+
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
     __S3_CLIENTS = {}
     __S3_DEFAULT_CLIENT = None
@@ -363,16 +364,15 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
-        if range is None :
+        if range is None:
             try:
                 reponse = requests.get(f"{storage_type.value}{path}", stream=True)
                 data = reponse.content
-                if reponse.status_code == 404 :
+                if reponse.status_code == 404:
                     raise FileNotFoundError(f"{storage_type.value}{path}")
             except Exception as e:
                 raise StorageError(storage_type.name, e)
-        else :
+        else:
             raise NotImplementedError
 
     else:
@@ -471,7 +471,6 @@ def get_size(path: str) -> int:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
         try:
             # Le stream=True permet de ne télécharger que le header initialement
             reponse = requests.get(storage_type.value + path, stream=True).headers["content-length"]
@@ -526,12 +525,11 @@ def exists(path: str) -> bool:
         return os.path.exists(path)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
         try:
             response = requests.get(storage_type.value + path, stream=True)
-            if response.status_code == 200 :
+            if response.status_code == 200:
                 return True
-            else :
+            else:
                 return False
         except Exception as e:
             raise StorageError(storage_type.name, e)
@@ -839,43 +837,52 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}"
             )
 
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.FILE :
-
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.FILE:
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream=True)
             with open(to_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=65536) :
+                for chunk in response.iter_content(chunk_size=65536):
                     if chunk:
                         f.write(chunk)
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and FILE", f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}")
-
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.CEPH :
+            raise StorageError(
+                f"HTTP(S) and FILE",
+                f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}",
+            )
 
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.CEPH:
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream=True)
             offset = 0
-            for chunk in response.iter_content(chunk_size=65536) :
+            for chunk in response.iter_content(chunk_size=65536):
                 if chunk:
                     size = len(chunk)
                     to_ioctx.write(to_base_name, chunk, offset)
                     offset += size
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and CEPH", f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}")
-
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.S3 :
+            raise StorageError(
+                f"HTTP(S) and CEPH",
+                f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}",
+            )
 
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.S3:
         to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
-            with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
+            response = requests.get(from_type.value + from_path, stream=True)
+            with tempfile.NamedTemporaryFile("w+b", delete=False) as f:
                 name_fich = f.name
-                for chunk in response.iter_content(chunk_size=65536) :
+                for chunk in response.iter_content(chunk_size=65536):
                     if chunk:
                         f.write(chunk)
 
@@ -884,7 +891,10 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             os.remove(name_fich)
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and S3", f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}")
+            raise StorageError(
+                f"HTTP(S) and S3",
+                f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}",
+            )
 
     else:
         raise StorageError(
@@ -998,7 +1008,8 @@ 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 :
+
+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:
@@ -1011,10 +1022,10 @@ def size_path(path: str) -> int :
     Returns:
         int: size of the path
     """
-    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
+    storage_type, unprefixed_path, tray_name, base_name = get_infos_from_path(path)
 
     if storage_type == StorageType.FILE:
-        try :
+        try:
             total = 0
             with os.scandir(unprefixed_path) as it:
                 for entry in it:
@@ -1029,24 +1040,23 @@ def size_path(path: str) -> int :
     elif storage_type == StorageType.S3:
         s3_client, bucket_name = __get_s3_client(tray_name)
 
-        try :
-            paginator = s3_client["client"].get_paginator('list_objects_v2')
+        try:
+            paginator = s3_client["client"].get_paginator("list_objects_v2")
             pages = paginator.paginate(
                 Bucket=bucket_name,
-                Prefix=base_name+"/",
+                Prefix=base_name + "/",
                 PaginationConfig={
-                    'PageSize': 10000,
-                }
+                    "PageSize": 10000,
+                },
             )
             total = 0
             for page in pages:
-                for key in page['Contents']:
-                    total += key['Size']
+                for key in page["Contents"]:
+                    total += key["Size"]
 
         except Exception as e:
             raise StorageError("S3", e)
 
-
     elif storage_type == StorageType.CEPH:
         raise NotImplementedError
     else:
diff --git a/src/rok4/TileMatrixSet.py b/src/rok4/TileMatrixSet.py
index 472810c..3000492 100644
--- a/src/rok4/TileMatrixSet.py
+++ b/src/rok4/TileMatrixSet.py
@@ -9,15 +9,15 @@
 - ROK4_TMS_DIRECTORY
 """
 
+import json
+import os
+from json.decoder import JSONDecodeError
+from typing import Dict, List, Tuple
+
 from rok4.Exceptions import *
 from rok4.Storage import get_data_str
 from rok4.Utils import *
 
-from typing import Dict, List, Tuple
-from json.decoder import JSONDecodeError
-import json
-import os
-
 
 class TileMatrix:
     """A tile matrix is a tile matrix set's level.
diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index da15aef..125e391 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -3,10 +3,10 @@
 
 import os
 import re
-
-from typing import Dict, List, Tuple, Union
-from osgeo import ogr, osr, gdal
 from enum import Enum
+from typing import Dict, List, Tuple, Union
+
+from osgeo import gdal, ogr, osr
 
 ogr.UseExceptions()
 osr.UseExceptions()
diff --git a/src/rok4/Vector.py b/src/rok4/Vector.py
index 94e6def..46656c2 100644
--- a/src/rok4/Vector.py
+++ b/src/rok4/Vector.py
@@ -6,12 +6,14 @@
 
 """
 
-from osgeo import ogr
-from rok4.Storage import get_osgeo_path, copy
-from rok4.Exceptions import *
 import os
 import tempfile
 
+from osgeo import ogr
+
+from rok4.Exceptions import *
+from rok4.Storage import copy, get_osgeo_path
+
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
diff --git a/tests/test_Layer.py b/tests/test_Layer.py
index 0a60d5c..a35f649 100644
--- a/tests/test_Layer.py
+++ b/tests/test_Layer.py
@@ -1,12 +1,12 @@
-from rok4.Layer import Layer
-from rok4.Pyramid import PyramidType
-from rok4.Exceptions import *
+import os
+from unittest import mock
+from unittest.mock import *
 
 import pytest
-import os
 
-from unittest.mock import *
-from unittest import mock
+from rok4.Exceptions import *
+from rok4.Layer import Layer
+from rok4.Pyramid import PyramidType
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
diff --git a/tests/test_Pyramid.py b/tests/test_Pyramid.py
index 6eebfd7..f5f1d60 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_Pyramid.py
@@ -1,13 +1,14 @@
+import os
+from unittest import mock
+from unittest.mock import *
+
+import pytest
+
+from rok4.Exceptions import *
 from rok4.Pyramid import *
-from rok4.TileMatrixSet import TileMatrixSet
 from rok4.Storage import StorageType
+from rok4.TileMatrixSet import TileMatrixSet
 from rok4.Utils import *
-from rok4.Exceptions import *
-
-import pytest
-import os
-from unittest.mock import *
-from unittest import mock
 
 
 @mock.patch("rok4.Pyramid.get_data_str", side_effect=StorageError("FILE", "Not found"))
diff --git a/tests/test_Raster.py b/tests/test_Raster.py
index de35de1..cc79846 100644
--- a/tests/test_Raster.py
+++ b/tests/test_Raster.py
@@ -6,17 +6,17 @@
 """
 
 import copy
-import math
 import json
+import math
 import random
+from unittest import TestCase, mock
+from unittest.mock import MagicMock, Mock, call, mock_open, patch
+
 import pytest
-from unittest import mock, TestCase
-from unittest.mock import call, MagicMock, Mock, mock_open, patch
 
 from rok4.Raster import Raster, RasterSet
 from rok4.Utils import ColorFormat
 
-
 # rok4.Raster.Raster class tests
 
 
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 9779954..f7b665d 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -1,14 +1,13 @@
-from rok4.Storage import *
-from rok4.Exceptions import *
-
-import pytest
 import os
+from unittest import mock
+from unittest.mock import *
 
 import botocore.exceptions
+import pytest
 from rados import ObjectNotFound
 
-from unittest import mock
-from unittest.mock import *
+from rok4.Exceptions import *
+from rok4.Storage import *
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
@@ -21,6 +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)
 def test_get_infos_from_path():
     assert (StorageType.S3, "toto/titi", "toto", "titi") == get_infos_from_path("s3://toto/titi")
@@ -103,6 +103,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"},
@@ -117,6 +118,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"},
@@ -159,8 +161,9 @@ def test_ceph_read_ok(mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH read raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("requests.get", side_effect={"status_code":404})
+@mock.patch("requests.get", side_effect={"status_code": 404})
 def test_http_read_error(mock_http):
     with pytest.raises(StorageError):
         requests_instance = MagicMock()
@@ -171,28 +174,31 @@ def test_http_read_error(mock_http):
 
     mock_http.assert_called_with("http://path/to/file.ext", stream=True)
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_http_read_range_error():
     with pytest.raises(NotImplementedError):
-        data = get_data_binary("http://path/to/file.ext", (0,100))
+        data = get_data_binary("http://path/to/file.ext", (0, 100))
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("requests.get")
 def test_http_read_ok(mock_http):
-    try :
+    try:
         requests_instance = MagicMock()
-        requests_instance.content = b'data'
+        requests_instance.content = b"data"
         mock_http.return_value = requests_instance
 
         data = get_data_str("http://path/to/file.ext")
         mock_http.assert_called_with("http://path/to/file.ext", stream=True)
-        assert data == 'data'
+        assert data == "data"
     except Exception as exc:
         assert False, f"HTTP read raises an exception: {exc}"
 
 
 ############ 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"},
@@ -225,6 +231,7 @@ def test_s3_write_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -302,6 +309,7 @@ def test_copy_s3_file_nok(mock_hash_file, mock_makedirs, mocked_s3_client):
         copy("s3://bucket/source.ext", "file:///path/to/destination.ext", "toto")
         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"},
@@ -320,6 +328,7 @@ def test_copy_file_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -338,6 +347,7 @@ def test_copy_s3_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -373,6 +383,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"},
@@ -399,6 +410,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"},
@@ -423,6 +435,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"},
@@ -487,14 +500,14 @@ def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH -> S3 copy raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
-@patch('builtins.open', new_callable=mock_open)
+@mock.patch("requests.get")
+@patch("builtins.open", new_callable=mock_open)
 def test_copy_http_file_ok(mock_open, mock_requests):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         copy("http://path/to/source.ext", "file:///path/to/destination.ext")
@@ -503,17 +516,20 @@ def test_copy_http_file_ok(mock_open, mock_requests):
     except Exception as exc:
         assert False, f"HTTP -> 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('rok4.Storage.rados.Rados')
-@mock.patch('requests.get')
+
+@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("requests.get")
 def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
-
         disconnect_ceph_clients()
         ioctx_instance = MagicMock()
         ioctx_instance.write.return_value = None
@@ -526,16 +542,20 @@ def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     except Exception as exc:
         assert False, f"HTTP -> CEPH 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('rok4.Storage.boto3.client')
-@mock.patch('requests.get')
-@patch('tempfile.NamedTemporaryFile', new_callable=mock_open)
-@mock.patch('os.remove')
+
+@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("requests.get")
+@patch("tempfile.NamedTemporaryFile", new_callable=mock_open)
+@mock.patch("os.remove")
 def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_client):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         disconnect_s3_clients()
@@ -546,7 +566,7 @@ def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_cl
 
         copy("http://path/to/source.ext", "s3://bucket/destination.ext")
         mock_requests.assert_called_once_with("http://path/to/source.ext", stream=True)
-        mock_tempfile.assert_called_once_with("w+b",delete=False)
+        mock_tempfile.assert_called_once_with("w+b", delete=False)
     except Exception as exc:
         assert False, f"HTTP -> CEPH copy raises an exception: {exc}"
 
@@ -563,6 +583,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("os.symlink", return_value=None)
 def test_link_file_ok(mock_link):
@@ -582,6 +603,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"},
@@ -619,6 +641,7 @@ def test_link_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -637,6 +660,7 @@ def test_link_s3_nok(mocked_s3_client):
 
 ############ get_size
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.stat")
 def test_size_file_ok(mock_stat):
@@ -647,6 +671,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"},
@@ -667,6 +692,7 @@ def test_size_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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"},
@@ -685,12 +711,12 @@ def test_size_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"S3 size raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_size_http_ok(mock_requests):
-
     http_instance = MagicMock()
-    http_instance.headers = {"content-length":12}
+    http_instance.headers = {"content-length": 12}
     mock_requests.return_value = http_instance
 
     try:
@@ -717,6 +743,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"},
@@ -768,10 +795,10 @@ def test_exists_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"CEPH not exists raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_exists_http_ok(mock_requests):
-
     http_instance = MagicMock()
     http_instance.status_code = 200
     mock_requests.return_value = http_instance
@@ -792,6 +819,7 @@ def test_exists_http_ok(mock_requests):
 
 ############ remove
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.remove")
 def test_remove_file_ok(mock_remove):
@@ -807,6 +835,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"},
@@ -832,6 +861,7 @@ def test_remove_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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"},
@@ -861,6 +891,7 @@ 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"},
@@ -881,6 +912,7 @@ def test_get_osgeo_path_nok():
     with pytest.raises(NotImplementedError):
         get_osgeo_path("ceph://pool/data.ext")
 
+
 ############ size_path
 def test_size_path_file_ok():
     try:
@@ -889,22 +921,31 @@ def test_size_path_file_ok():
     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) :
+    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)
-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,
+)
+def test_size_path_ceph_nok():
     with pytest.raises(NotImplementedError):
         size = size_path("ceph://pool/path")
 
-@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):
 
+@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}]}]
+    pages = [{"Contents": [{"Size": 10}, {"Size": 20}]}, {"Contents": [{"Size": 50}]}]
     paginator = MagicMock()
     paginator.paginate.return_value = pages
     client = MagicMock()
@@ -916,4 +957,3 @@ def test_size_path_s3_ok(mocked_s3_client):
         assert size == 80
     except Exception as exc:
         assert False, f"S3 size of the path raises an exception: {exc}"
-
diff --git a/tests/test_TileMatrixSet.py b/tests/test_TileMatrixSet.py
index 4750f50..5cf6062 100644
--- a/tests/test_TileMatrixSet.py
+++ b/tests/test_TileMatrixSet.py
@@ -1,10 +1,11 @@
-from rok4.TileMatrixSet import TileMatrixSet
-from rok4.Exceptions import *
-
-import pytest
 import os
-from unittest.mock import *
 from unittest import mock
+from unittest.mock import *
+
+import pytest
+
+from rok4.Exceptions import *
+from rok4.TileMatrixSet import TileMatrixSet
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
diff --git a/tests/test_Utils.py b/tests/test_Utils.py
index cdba571..0f5d67d 100644
--- a/tests/test_Utils.py
+++ b/tests/test_Utils.py
@@ -1,14 +1,14 @@
-from rok4.Utils import *
-from rok4.Exceptions import *
+import math
+import os
+import random
+from unittest import mock
+from unittest.mock import *
 
 import pytest
-import os
 from osgeo import gdal, osr
-import math
-import random
 
-from unittest.mock import *
-from unittest import mock
+from rok4.Exceptions import *
+from rok4.Utils import *
 
 
 def test_srs_to_spatialreference_ignf_ok():
diff --git a/tests/test_Vector.py b/tests/test_Vector.py
index 221f5e4..3fe0a1c 100644
--- a/tests/test_Vector.py
+++ b/tests/test_Vector.py
@@ -1,12 +1,13 @@
 #!/usr/bin/env python3
-from rok4.Vector import *
-from rok4.Exceptions import *
-from rok4.Storage import disconnect_ceph_clients
-
-import pytest
 import os
-from unittest.mock import *
 from unittest import mock
+from unittest.mock import *
+
+import pytest
+
+from rok4.Exceptions import *
+from rok4.Storage import disconnect_ceph_clients
+from rok4.Vector import *
 
 
 @mock.patch.dict(os.environ, {}, clear=True)

From 3b2e580270f1d283ba6f350786596737f19d41fb Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 12:43:44 +0200
Subject: [PATCH 59/89] Specify target Python version to black

---
 .pre-commit-config.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 31a1cee..2470e26 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -25,3 +25,4 @@ repos:
     rev: 23.3.0
     hooks:
       - id: black
+        args: ["--target-version=py38"]

From 3fd1c93ac2ba14385ada5e760d5e2bf0870d3964 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 12:50:35 +0200
Subject: [PATCH 60/89] Rename files to comply with Python convention PEP8

---
 src/rok4/{Exceptions.py => exceptions.py}     |   0
 src/rok4/{Layer.py => layer.py}               |  10 +-
 src/rok4/{Pyramid.py => pyramid.py}           |  28 ++---
 src/rok4/{Raster.py => raster.py}             |   4 +-
 src/rok4/{Storage.py => storage.py}           |  85 +++++++------
 .../{TileMatrixSet.py => tile_matrix_set.py}  |   6 +-
 src/rok4/{Utils.py => utils.py}               |   0
 src/rok4/{Vector.py => vector.py}             |   4 +-
 tests/{test_Layer.py => test_layer.py}        |   6 +-
 tests/{test_Pyramid.py => test_pyramid.py}    |  10 +-
 tests/{test_Raster.py => test_raster.py}      |   4 +-
 tests/{test_Storage.py => test_storage.py}    | 117 ++++++++++++------
 ...leMatrixSet.py => test_tile_matrix_set.py} |   4 +-
 tests/{test_Utils.py => test_utils.py}        |   4 +-
 tests/{test_Vector.py => test_vector.py}      |   6 +-
 15 files changed, 167 insertions(+), 121 deletions(-)
 rename src/rok4/{Exceptions.py => exceptions.py} (100%)
 rename src/rok4/{Layer.py => layer.py} (98%)
 rename src/rok4/{Pyramid.py => pyramid.py} (99%)
 rename src/rok4/{Raster.py => raster.py} (98%)
 rename src/rok4/{Storage.py => storage.py} (95%)
 rename src/rok4/{TileMatrixSet.py => tile_matrix_set.py} (98%)
 rename src/rok4/{Utils.py => utils.py} (100%)
 rename src/rok4/{Vector.py => vector.py} (99%)
 rename tests/{test_Layer.py => test_layer.py} (98%)
 rename tests/{test_Pyramid.py => test_pyramid.py} (98%)
 rename tests/{test_Raster.py => test_raster.py} (99%)
 rename tests/{test_Storage.py => test_storage.py} (94%)
 rename tests/{test_TileMatrixSet.py => test_tile_matrix_set.py} (99%)
 rename tests/{test_Utils.py => test_utils.py} (99%)
 rename tests/{test_Vector.py => test_vector.py} (97%)

diff --git a/src/rok4/Exceptions.py b/src/rok4/exceptions.py
similarity index 100%
rename from src/rok4/Exceptions.py
rename to src/rok4/exceptions.py
diff --git a/src/rok4/Layer.py b/src/rok4/layer.py
similarity index 98%
rename from src/rok4/Layer.py
rename to src/rok4/layer.py
index 316a9ca..f7a891b 100644
--- a/src/rok4/Layer.py
+++ b/src/rok4/layer.py
@@ -11,11 +11,11 @@
 import os
 import re
 
-from rok4.Exceptions import *
-from rok4.Pyramid import Pyramid, PyramidType
-from rok4.TileMatrixSet import TileMatrixSet
-from rok4.Storage import *
-from rok4.Utils import *
+from rok4.exceptions import *
+from rok4.pyramid import Pyramid, PyramidType
+from rok4.tile_matrix_set import TileMatrixSet
+from rok4.storage import *
+from rok4.utils import *
 
 
 class Layer:
diff --git a/src/rok4/Pyramid.py b/src/rok4/pyramid.py
similarity index 99%
rename from src/rok4/Pyramid.py
rename to src/rok4/pyramid.py
index 7667244..8ca8afc 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/pyramid.py
@@ -17,10 +17,10 @@
 import mapbox_vector_tile
 from PIL import Image
 
-from rok4.Exceptions import *
-from rok4.TileMatrixSet import TileMatrixSet, TileMatrix
-from rok4.Storage import *
-from rok4.Utils import *
+from rok4.exceptions import *
+from rok4.tile_matrix_set import TileMatrixSet, TileMatrix
+from rok4.storage import *
+from rok4.utils import *
 
 
 class PyramidType(Enum):
@@ -549,11 +549,8 @@ def serializable(self) -> Dict:
         Returns:
             Dict: descriptor structured object description
         """
-        
-        serialization = {
-            "tile_matrix_set": self.__tms.name,
-            "format": self.__format
-        }
+
+        serialization = {"tile_matrix_set": self.__tms.name, "format": self.__format}
 
         serialization["levels"] = []
         sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
@@ -620,7 +617,7 @@ def storage_root(self) -> str:
         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
@@ -670,7 +667,6 @@ def format(self) -> str:
 
     @property
     def tile_extension(self) -> str:
-
         if self.__format in [
             "TIFF_RAW_UINT8",
             "TIFF_LZW_UINT8",
@@ -835,7 +831,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)
 
     def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
@@ -1019,7 +1015,6 @@ def get_slab_path_from_infos(
         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
 
@@ -1182,7 +1177,6 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
         level_object = self.get_level(level)
 
         if self.__format == "TIFF_JPG_UINT8" or self.__format == "TIFF_JPG90_UINT8":
-
             try:
                 img = Image.open(io.BytesIO(binary_tile))
             except Exception as e:
@@ -1379,6 +1373,8 @@ def size(self) -> int:
         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))
+        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/Raster.py b/src/rok4/raster.py
similarity index 98%
rename from src/rok4/Raster.py
rename to src/rok4/raster.py
index 640f4bf..c86901b 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/raster.py
@@ -14,8 +14,8 @@
 
 from osgeo import ogr, gdal
 
-from rok4.Storage import exists, get_osgeo_path, put_data_str
-from rok4.Utils import ColorFormat, compute_bbox, compute_format
+from rok4.storage import exists, get_osgeo_path, put_data_str
+from rok4.utils import ColorFormat, compute_bbox, compute_format
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
diff --git a/src/rok4/Storage.py b/src/rok4/storage.py
similarity index 95%
rename from src/rok4/Storage.py
rename to src/rok4/storage.py
index bcbee52..3015e5e 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/storage.py
@@ -45,7 +45,7 @@
 
 gdal.UseExceptions()
 
-from rok4.Exceptions import *
+from rok4.exceptions import *
 
 
 class StorageType(Enum):
@@ -75,7 +75,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
     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:
@@ -134,7 +134,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
 
 def disconnect_s3_clients() -> None:
     """Clean S3 clients"""
-  
+
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
     __S3_CLIENTS = {}
     __S3_DEFAULT_CLIENT = None
@@ -363,16 +363,15 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
-        if range is None :
+        if range is None:
             try:
                 reponse = requests.get(f"{storage_type.value}{path}", stream=True)
                 data = reponse.content
-                if reponse.status_code == 404 :
+                if reponse.status_code == 404:
                     raise FileNotFoundError(f"{storage_type.value}{path}")
             except Exception as e:
                 raise StorageError(storage_type.name, e)
-        else :
+        else:
             raise NotImplementedError
 
     else:
@@ -471,7 +470,6 @@ def get_size(path: str) -> int:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
         try:
             # Le stream=True permet de ne télécharger que le header initialement
             reponse = requests.get(storage_type.value + path, stream=True).headers["content-length"]
@@ -526,12 +524,11 @@ def exists(path: str) -> bool:
         return os.path.exists(path)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
         try:
             response = requests.get(storage_type.value + path, stream=True)
-            if response.status_code == 200 :
+            if response.status_code == 200:
                 return True
-            else :
+            else:
                 return False
         except Exception as e:
             raise StorageError(storage_type.name, e)
@@ -839,43 +836,52 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}"
             )
 
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.FILE :
-
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.FILE:
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream=True)
             with open(to_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=65536) :
+                for chunk in response.iter_content(chunk_size=65536):
                     if chunk:
                         f.write(chunk)
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and FILE", f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}")
-
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.CEPH :
+            raise StorageError(
+                f"HTTP(S) and FILE",
+                f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}",
+            )
 
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.CEPH:
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream=True)
             offset = 0
-            for chunk in response.iter_content(chunk_size=65536) :
+            for chunk in response.iter_content(chunk_size=65536):
                 if chunk:
                     size = len(chunk)
                     to_ioctx.write(to_base_name, chunk, offset)
                     offset += size
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and CEPH", f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}")
-
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.S3 :
+            raise StorageError(
+                f"HTTP(S) and CEPH",
+                f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}",
+            )
 
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.S3:
         to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
-            with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
+            response = requests.get(from_type.value + from_path, stream=True)
+            with tempfile.NamedTemporaryFile("w+b", delete=False) as f:
                 name_fich = f.name
-                for chunk in response.iter_content(chunk_size=65536) :
+                for chunk in response.iter_content(chunk_size=65536):
                     if chunk:
                         f.write(chunk)
 
@@ -884,7 +890,10 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             os.remove(name_fich)
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and S3", f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}")
+            raise StorageError(
+                f"HTTP(S) and S3",
+                f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}",
+            )
 
     else:
         raise StorageError(
@@ -998,7 +1007,8 @@ 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 :
+
+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:
@@ -1011,10 +1021,10 @@ def size_path(path: str) -> int :
     Returns:
         int: size of the path
     """
-    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
+    storage_type, unprefixed_path, tray_name, base_name = get_infos_from_path(path)
 
     if storage_type == StorageType.FILE:
-        try :
+        try:
             total = 0
             with os.scandir(unprefixed_path) as it:
                 for entry in it:
@@ -1029,24 +1039,23 @@ def size_path(path: str) -> int :
     elif storage_type == StorageType.S3:
         s3_client, bucket_name = __get_s3_client(tray_name)
 
-        try :
-            paginator = s3_client["client"].get_paginator('list_objects_v2')
+        try:
+            paginator = s3_client["client"].get_paginator("list_objects_v2")
             pages = paginator.paginate(
                 Bucket=bucket_name,
-                Prefix=base_name+"/",
+                Prefix=base_name + "/",
                 PaginationConfig={
-                    'PageSize': 10000,
-                }
+                    "PageSize": 10000,
+                },
             )
             total = 0
             for page in pages:
-                for key in page['Contents']:
-                    total += key['Size']
+                for key in page["Contents"]:
+                    total += key["Size"]
 
         except Exception as e:
             raise StorageError("S3", e)
 
-
     elif storage_type == StorageType.CEPH:
         raise NotImplementedError
     else:
diff --git a/src/rok4/TileMatrixSet.py b/src/rok4/tile_matrix_set.py
similarity index 98%
rename from src/rok4/TileMatrixSet.py
rename to src/rok4/tile_matrix_set.py
index 472810c..037e6b6 100644
--- a/src/rok4/TileMatrixSet.py
+++ b/src/rok4/tile_matrix_set.py
@@ -9,9 +9,9 @@
 - ROK4_TMS_DIRECTORY
 """
 
-from rok4.Exceptions import *
-from rok4.Storage import get_data_str
-from rok4.Utils import *
+from rok4.exceptions import *
+from rok4.storage import get_data_str
+from rok4.utils import *
 
 from typing import Dict, List, Tuple
 from json.decoder import JSONDecodeError
diff --git a/src/rok4/Utils.py b/src/rok4/utils.py
similarity index 100%
rename from src/rok4/Utils.py
rename to src/rok4/utils.py
diff --git a/src/rok4/Vector.py b/src/rok4/vector.py
similarity index 99%
rename from src/rok4/Vector.py
rename to src/rok4/vector.py
index 94e6def..b12261a 100644
--- a/src/rok4/Vector.py
+++ b/src/rok4/vector.py
@@ -7,8 +7,8 @@
 """
 
 from osgeo import ogr
-from rok4.Storage import get_osgeo_path, copy
-from rok4.Exceptions import *
+from rok4.storage import get_osgeo_path, copy
+from rok4.exceptions import *
 import os
 import tempfile
 
diff --git a/tests/test_Layer.py b/tests/test_layer.py
similarity index 98%
rename from tests/test_Layer.py
rename to tests/test_layer.py
index 0a60d5c..ecc140e 100644
--- a/tests/test_Layer.py
+++ b/tests/test_layer.py
@@ -1,6 +1,6 @@
-from rok4.Layer import Layer
-from rok4.Pyramid import PyramidType
-from rok4.Exceptions import *
+from rok4.layer import Layer
+from rok4.pyramid import PyramidType
+from rok4.exceptions import *
 
 import pytest
 import os
diff --git a/tests/test_Pyramid.py b/tests/test_pyramid.py
similarity index 98%
rename from tests/test_Pyramid.py
rename to tests/test_pyramid.py
index 6eebfd7..14cda2d 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_pyramid.py
@@ -1,8 +1,8 @@
-from rok4.Pyramid import *
-from rok4.TileMatrixSet import TileMatrixSet
-from rok4.Storage import StorageType
-from rok4.Utils import *
-from rok4.Exceptions import *
+from rok4.pyramid import *
+from rok4.tile_matrix_set import TileMatrixSet
+from rok4.storage import StorageType
+from rok4.utils import *
+from rok4.exceptions import *
 
 import pytest
 import os
diff --git a/tests/test_Raster.py b/tests/test_raster.py
similarity index 99%
rename from tests/test_Raster.py
rename to tests/test_raster.py
index de35de1..ae466a5 100644
--- a/tests/test_Raster.py
+++ b/tests/test_raster.py
@@ -13,8 +13,8 @@
 from unittest import mock, TestCase
 from unittest.mock import call, MagicMock, Mock, mock_open, patch
 
-from rok4.Raster import Raster, RasterSet
-from rok4.Utils import ColorFormat
+from rok4.raster import Raster, RasterSet
+from rok4.utils import ColorFormat
 
 
 # rok4.Raster.Raster class tests
diff --git a/tests/test_Storage.py b/tests/test_storage.py
similarity index 94%
rename from tests/test_Storage.py
rename to tests/test_storage.py
index 9779954..8e0f90a 100644
--- a/tests/test_Storage.py
+++ b/tests/test_storage.py
@@ -1,5 +1,5 @@
-from rok4.Storage import *
-from rok4.Exceptions import *
+from rok4.storage import *
+from rok4.exceptions import *
 
 import pytest
 import os
@@ -21,6 +21,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)
 def test_get_infos_from_path():
     assert (StorageType.S3, "toto/titi", "toto", "titi") == get_infos_from_path("s3://toto/titi")
@@ -103,6 +104,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"},
@@ -117,6 +119,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"},
@@ -159,8 +162,9 @@ def test_ceph_read_ok(mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH read raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("requests.get", side_effect={"status_code":404})
+@mock.patch("requests.get", side_effect={"status_code": 404})
 def test_http_read_error(mock_http):
     with pytest.raises(StorageError):
         requests_instance = MagicMock()
@@ -171,28 +175,31 @@ def test_http_read_error(mock_http):
 
     mock_http.assert_called_with("http://path/to/file.ext", stream=True)
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_http_read_range_error():
     with pytest.raises(NotImplementedError):
-        data = get_data_binary("http://path/to/file.ext", (0,100))
+        data = get_data_binary("http://path/to/file.ext", (0, 100))
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("requests.get")
 def test_http_read_ok(mock_http):
-    try :
+    try:
         requests_instance = MagicMock()
-        requests_instance.content = b'data'
+        requests_instance.content = b"data"
         mock_http.return_value = requests_instance
 
         data = get_data_str("http://path/to/file.ext")
         mock_http.assert_called_with("http://path/to/file.ext", stream=True)
-        assert data == 'data'
+        assert data == "data"
     except Exception as exc:
         assert False, f"HTTP read raises an exception: {exc}"
 
 
 ############ 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"},
@@ -225,6 +232,7 @@ def test_s3_write_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -302,6 +310,7 @@ def test_copy_s3_file_nok(mock_hash_file, mock_makedirs, mocked_s3_client):
         copy("s3://bucket/source.ext", "file:///path/to/destination.ext", "toto")
         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"},
@@ -320,6 +329,7 @@ def test_copy_file_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -338,6 +348,7 @@ def test_copy_s3_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -373,6 +384,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"},
@@ -399,6 +411,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"},
@@ -423,6 +436,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"},
@@ -487,14 +501,14 @@ def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH -> S3 copy raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
-@patch('builtins.open', new_callable=mock_open)
+@mock.patch("requests.get")
+@patch("builtins.open", new_callable=mock_open)
 def test_copy_http_file_ok(mock_open, mock_requests):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         copy("http://path/to/source.ext", "file:///path/to/destination.ext")
@@ -503,17 +517,20 @@ def test_copy_http_file_ok(mock_open, mock_requests):
     except Exception as exc:
         assert False, f"HTTP -> 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('rok4.Storage.rados.Rados')
-@mock.patch('requests.get')
+
+@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("requests.get")
 def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
-
         disconnect_ceph_clients()
         ioctx_instance = MagicMock()
         ioctx_instance.write.return_value = None
@@ -526,16 +543,20 @@ def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     except Exception as exc:
         assert False, f"HTTP -> CEPH 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('rok4.Storage.boto3.client')
-@mock.patch('requests.get')
-@patch('tempfile.NamedTemporaryFile', new_callable=mock_open)
-@mock.patch('os.remove')
+
+@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("requests.get")
+@patch("tempfile.NamedTemporaryFile", new_callable=mock_open)
+@mock.patch("os.remove")
 def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_client):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         disconnect_s3_clients()
@@ -546,7 +567,7 @@ def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_cl
 
         copy("http://path/to/source.ext", "s3://bucket/destination.ext")
         mock_requests.assert_called_once_with("http://path/to/source.ext", stream=True)
-        mock_tempfile.assert_called_once_with("w+b",delete=False)
+        mock_tempfile.assert_called_once_with("w+b", delete=False)
     except Exception as exc:
         assert False, f"HTTP -> CEPH copy raises an exception: {exc}"
 
@@ -563,6 +584,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("os.symlink", return_value=None)
 def test_link_file_ok(mock_link):
@@ -582,6 +604,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"},
@@ -619,6 +642,7 @@ def test_link_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -637,6 +661,7 @@ def test_link_s3_nok(mocked_s3_client):
 
 ############ get_size
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.stat")
 def test_size_file_ok(mock_stat):
@@ -647,6 +672,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"},
@@ -667,6 +693,7 @@ def test_size_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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"},
@@ -685,12 +712,12 @@ def test_size_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"S3 size raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_size_http_ok(mock_requests):
-
     http_instance = MagicMock()
-    http_instance.headers = {"content-length":12}
+    http_instance.headers = {"content-length": 12}
     mock_requests.return_value = http_instance
 
     try:
@@ -717,6 +744,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"},
@@ -768,10 +796,10 @@ def test_exists_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"CEPH not exists raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_exists_http_ok(mock_requests):
-
     http_instance = MagicMock()
     http_instance.status_code = 200
     mock_requests.return_value = http_instance
@@ -792,6 +820,7 @@ def test_exists_http_ok(mock_requests):
 
 ############ remove
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.remove")
 def test_remove_file_ok(mock_remove):
@@ -807,6 +836,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"},
@@ -832,6 +862,7 @@ def test_remove_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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"},
@@ -861,6 +892,7 @@ 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"},
@@ -881,6 +913,7 @@ def test_get_osgeo_path_nok():
     with pytest.raises(NotImplementedError):
         get_osgeo_path("ceph://pool/data.ext")
 
+
 ############ size_path
 def test_size_path_file_ok():
     try:
@@ -889,22 +922,31 @@ def test_size_path_file_ok():
     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) :
+    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)
-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,
+)
+def test_size_path_ceph_nok():
     with pytest.raises(NotImplementedError):
         size = size_path("ceph://pool/path")
 
-@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):
 
+@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}]}]
+    pages = [{"Contents": [{"Size": 10}, {"Size": 20}]}, {"Contents": [{"Size": 50}]}]
     paginator = MagicMock()
     paginator.paginate.return_value = pages
     client = MagicMock()
@@ -916,4 +958,3 @@ def test_size_path_s3_ok(mocked_s3_client):
         assert size == 80
     except Exception as exc:
         assert False, f"S3 size of the path raises an exception: {exc}"
-
diff --git a/tests/test_TileMatrixSet.py b/tests/test_tile_matrix_set.py
similarity index 99%
rename from tests/test_TileMatrixSet.py
rename to tests/test_tile_matrix_set.py
index 4750f50..350669b 100644
--- a/tests/test_TileMatrixSet.py
+++ b/tests/test_tile_matrix_set.py
@@ -1,5 +1,5 @@
-from rok4.TileMatrixSet import TileMatrixSet
-from rok4.Exceptions import *
+from rok4.tile_matrix_set import TileMatrixSet
+from rok4.exceptions import *
 
 import pytest
 import os
diff --git a/tests/test_Utils.py b/tests/test_utils.py
similarity index 99%
rename from tests/test_Utils.py
rename to tests/test_utils.py
index cdba571..a5d93b3 100644
--- a/tests/test_Utils.py
+++ b/tests/test_utils.py
@@ -1,5 +1,5 @@
-from rok4.Utils import *
-from rok4.Exceptions import *
+from rok4.utils import *
+from rok4.exceptions import *
 
 import pytest
 import os
diff --git a/tests/test_Vector.py b/tests/test_vector.py
similarity index 97%
rename from tests/test_Vector.py
rename to tests/test_vector.py
index 221f5e4..dbecde2 100644
--- a/tests/test_Vector.py
+++ b/tests/test_vector.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
-from rok4.Vector import *
-from rok4.Exceptions import *
-from rok4.Storage import disconnect_ceph_clients
+from rok4.vector import *
+from rok4.exceptions import *
+from rok4.storage import disconnect_ceph_clients
 
 import pytest
 import os

From c8a51a0158bfc6bb737d67af77b178c10168f9cd Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 14:50:00 +0200
Subject: [PATCH 61/89] Move StorageType to enums module

---
 src/rok4/Pyramid.py   |  21 ++++----
 src/rok4/Storage.py   |  92 +++++++++++++++++-----------------
 src/rok4/enums.py     |  14 ++++++
 tests/test_Pyramid.py |   2 +-
 tests/test_Storage.py | 114 +++++++++++++++++++++++++++++-------------
 5 files changed, 149 insertions(+), 94 deletions(-)
 create mode 100644 src/rok4/enums.py

diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 7667244..fd01f1d 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -21,6 +21,7 @@
 from rok4.TileMatrixSet import TileMatrixSet, TileMatrix
 from rok4.Storage import *
 from rok4.Utils import *
+from rok4.enums import StorageType
 
 
 class PyramidType(Enum):
@@ -549,11 +550,8 @@ def serializable(self) -> Dict:
         Returns:
             Dict: descriptor structured object description
         """
-        
-        serialization = {
-            "tile_matrix_set": self.__tms.name,
-            "format": self.__format
-        }
+
+        serialization = {"tile_matrix_set": self.__tms.name, "format": self.__format}
 
         serialization["levels"] = []
         sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
@@ -620,7 +618,7 @@ def storage_root(self) -> str:
         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
@@ -670,7 +668,6 @@ def format(self) -> str:
 
     @property
     def tile_extension(self) -> str:
-
         if self.__format in [
             "TIFF_RAW_UINT8",
             "TIFF_LZW_UINT8",
@@ -835,7 +832,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)
 
     def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
@@ -1019,7 +1016,6 @@ def get_slab_path_from_infos(
         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
 
@@ -1182,7 +1178,6 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
         level_object = self.get_level(level)
 
         if self.__format == "TIFF_JPG_UINT8" or self.__format == "TIFF_JPG90_UINT8":
-
             try:
                 img = Image.open(io.BytesIO(binary_tile))
             except Exception as e:
@@ -1379,6 +1374,8 @@ def size(self) -> int:
         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))
+        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 bcbee52..406e431 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/Storage.py
@@ -45,17 +45,10 @@
 
 gdal.UseExceptions()
 
+from rok4.enums import StorageType
 from rok4.Exceptions import *
 
 
-class StorageType(Enum):
-    FILE = "file://"
-    S3 = "s3://"
-    CEPH = "ceph://"
-    HTTP = "http://"
-    HTTPS = "https://"
-
-
 __S3_CLIENTS = {}
 __S3_DEFAULT_CLIENT = None
 
@@ -75,7 +68,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
     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:
@@ -134,7 +127,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
 
 def disconnect_s3_clients() -> None:
     """Clean S3 clients"""
-  
+
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
     __S3_CLIENTS = {}
     __S3_DEFAULT_CLIENT = None
@@ -363,16 +356,15 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
-        if range is None :
+        if range is None:
             try:
                 reponse = requests.get(f"{storage_type.value}{path}", stream=True)
                 data = reponse.content
-                if reponse.status_code == 404 :
+                if reponse.status_code == 404:
                     raise FileNotFoundError(f"{storage_type.value}{path}")
             except Exception as e:
                 raise StorageError(storage_type.name, e)
-        else :
+        else:
             raise NotImplementedError
 
     else:
@@ -471,7 +463,6 @@ def get_size(path: str) -> int:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
         try:
             # Le stream=True permet de ne télécharger que le header initialement
             reponse = requests.get(storage_type.value + path, stream=True).headers["content-length"]
@@ -526,12 +517,11 @@ def exists(path: str) -> bool:
         return os.path.exists(path)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
         try:
             response = requests.get(storage_type.value + path, stream=True)
-            if response.status_code == 200 :
+            if response.status_code == 200:
                 return True
-            else :
+            else:
                 return False
         except Exception as e:
             raise StorageError(storage_type.name, e)
@@ -839,43 +829,52 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}"
             )
 
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.FILE :
-
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.FILE:
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream=True)
             with open(to_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=65536) :
+                for chunk in response.iter_content(chunk_size=65536):
                     if chunk:
                         f.write(chunk)
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and FILE", f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}")
-
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.CEPH :
+            raise StorageError(
+                f"HTTP(S) and FILE",
+                f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}",
+            )
 
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.CEPH:
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream=True)
             offset = 0
-            for chunk in response.iter_content(chunk_size=65536) :
+            for chunk in response.iter_content(chunk_size=65536):
                 if chunk:
                     size = len(chunk)
                     to_ioctx.write(to_base_name, chunk, offset)
                     offset += size
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and CEPH", f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}")
-
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.S3 :
+            raise StorageError(
+                f"HTTP(S) and CEPH",
+                f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}",
+            )
 
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.S3:
         to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
-            with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
+            response = requests.get(from_type.value + from_path, stream=True)
+            with tempfile.NamedTemporaryFile("w+b", delete=False) as f:
                 name_fich = f.name
-                for chunk in response.iter_content(chunk_size=65536) :
+                for chunk in response.iter_content(chunk_size=65536):
                     if chunk:
                         f.write(chunk)
 
@@ -884,7 +883,10 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             os.remove(name_fich)
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and S3", f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}")
+            raise StorageError(
+                f"HTTP(S) and S3",
+                f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}",
+            )
 
     else:
         raise StorageError(
@@ -998,7 +1000,8 @@ 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 :
+
+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:
@@ -1011,10 +1014,10 @@ def size_path(path: str) -> int :
     Returns:
         int: size of the path
     """
-    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
+    storage_type, unprefixed_path, tray_name, base_name = get_infos_from_path(path)
 
     if storage_type == StorageType.FILE:
-        try :
+        try:
             total = 0
             with os.scandir(unprefixed_path) as it:
                 for entry in it:
@@ -1029,24 +1032,23 @@ def size_path(path: str) -> int :
     elif storage_type == StorageType.S3:
         s3_client, bucket_name = __get_s3_client(tray_name)
 
-        try :
-            paginator = s3_client["client"].get_paginator('list_objects_v2')
+        try:
+            paginator = s3_client["client"].get_paginator("list_objects_v2")
             pages = paginator.paginate(
                 Bucket=bucket_name,
-                Prefix=base_name+"/",
+                Prefix=base_name + "/",
                 PaginationConfig={
-                    'PageSize': 10000,
-                }
+                    "PageSize": 10000,
+                },
             )
             total = 0
             for page in pages:
-                for key in page['Contents']:
-                    total += key['Size']
+                for key in page["Contents"]:
+                    total += key["Size"]
 
         except Exception as e:
             raise StorageError("S3", e)
 
-
     elif storage_type == StorageType.CEPH:
         raise NotImplementedError
     else:
diff --git a/src/rok4/enums.py b/src/rok4/enums.py
new file mode 100644
index 0000000..2fca210
--- /dev/null
+++ b/src/rok4/enums.py
@@ -0,0 +1,14 @@
+#! python3  # noqa: E265
+
+# standard lib
+from enum import Enum
+
+
+class StorageType(Enum):
+    """Matrice de correspondance entre type de stockage et protocole."""
+
+    CEPH = "ceph://"
+    FILE = "file://"
+    HTTP = "http://"
+    HTTPS = "https://"
+    S3 = "s3://"
diff --git a/tests/test_Pyramid.py b/tests/test_Pyramid.py
index 6eebfd7..d72ce2f 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_Pyramid.py
@@ -1,6 +1,6 @@
 from rok4.Pyramid import *
 from rok4.TileMatrixSet import TileMatrixSet
-from rok4.Storage import StorageType
+from rok4.enums import StorageType
 from rok4.Utils import *
 from rok4.Exceptions import *
 
diff --git a/tests/test_Storage.py b/tests/test_Storage.py
index 9779954..540632c 100644
--- a/tests/test_Storage.py
+++ b/tests/test_Storage.py
@@ -1,5 +1,6 @@
 from rok4.Storage import *
 from rok4.Exceptions import *
+from rok4.enums import StorageType
 
 import pytest
 import os
@@ -21,6 +22,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)
 def test_get_infos_from_path():
     assert (StorageType.S3, "toto/titi", "toto", "titi") == get_infos_from_path("s3://toto/titi")
@@ -103,6 +105,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"},
@@ -117,6 +120,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"},
@@ -159,8 +163,9 @@ def test_ceph_read_ok(mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH read raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("requests.get", side_effect={"status_code":404})
+@mock.patch("requests.get", side_effect={"status_code": 404})
 def test_http_read_error(mock_http):
     with pytest.raises(StorageError):
         requests_instance = MagicMock()
@@ -171,28 +176,31 @@ def test_http_read_error(mock_http):
 
     mock_http.assert_called_with("http://path/to/file.ext", stream=True)
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_http_read_range_error():
     with pytest.raises(NotImplementedError):
-        data = get_data_binary("http://path/to/file.ext", (0,100))
+        data = get_data_binary("http://path/to/file.ext", (0, 100))
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("requests.get")
 def test_http_read_ok(mock_http):
-    try :
+    try:
         requests_instance = MagicMock()
-        requests_instance.content = b'data'
+        requests_instance.content = b"data"
         mock_http.return_value = requests_instance
 
         data = get_data_str("http://path/to/file.ext")
         mock_http.assert_called_with("http://path/to/file.ext", stream=True)
-        assert data == 'data'
+        assert data == "data"
     except Exception as exc:
         assert False, f"HTTP read raises an exception: {exc}"
 
 
 ############ 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"},
@@ -225,6 +233,7 @@ def test_s3_write_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -302,6 +311,7 @@ def test_copy_s3_file_nok(mock_hash_file, mock_makedirs, mocked_s3_client):
         copy("s3://bucket/source.ext", "file:///path/to/destination.ext", "toto")
         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"},
@@ -320,6 +330,7 @@ def test_copy_file_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -338,6 +349,7 @@ def test_copy_s3_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -373,6 +385,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"},
@@ -399,6 +412,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"},
@@ -423,6 +437,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"},
@@ -487,14 +502,14 @@ def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH -> S3 copy raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
-@patch('builtins.open', new_callable=mock_open)
+@mock.patch("requests.get")
+@patch("builtins.open", new_callable=mock_open)
 def test_copy_http_file_ok(mock_open, mock_requests):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         copy("http://path/to/source.ext", "file:///path/to/destination.ext")
@@ -503,17 +518,20 @@ def test_copy_http_file_ok(mock_open, mock_requests):
     except Exception as exc:
         assert False, f"HTTP -> 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('rok4.Storage.rados.Rados')
-@mock.patch('requests.get')
+
+@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("requests.get")
 def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
-
         disconnect_ceph_clients()
         ioctx_instance = MagicMock()
         ioctx_instance.write.return_value = None
@@ -526,16 +544,20 @@ def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     except Exception as exc:
         assert False, f"HTTP -> CEPH 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('rok4.Storage.boto3.client')
-@mock.patch('requests.get')
-@patch('tempfile.NamedTemporaryFile', new_callable=mock_open)
-@mock.patch('os.remove')
+
+@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("requests.get")
+@patch("tempfile.NamedTemporaryFile", new_callable=mock_open)
+@mock.patch("os.remove")
 def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_client):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         disconnect_s3_clients()
@@ -546,7 +568,7 @@ def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_cl
 
         copy("http://path/to/source.ext", "s3://bucket/destination.ext")
         mock_requests.assert_called_once_with("http://path/to/source.ext", stream=True)
-        mock_tempfile.assert_called_once_with("w+b",delete=False)
+        mock_tempfile.assert_called_once_with("w+b", delete=False)
     except Exception as exc:
         assert False, f"HTTP -> CEPH copy raises an exception: {exc}"
 
@@ -563,6 +585,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("os.symlink", return_value=None)
 def test_link_file_ok(mock_link):
@@ -582,6 +605,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"},
@@ -619,6 +643,7 @@ def test_link_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -637,6 +662,7 @@ def test_link_s3_nok(mocked_s3_client):
 
 ############ get_size
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.stat")
 def test_size_file_ok(mock_stat):
@@ -647,6 +673,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"},
@@ -667,6 +694,7 @@ def test_size_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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"},
@@ -685,12 +713,12 @@ def test_size_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"S3 size raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_size_http_ok(mock_requests):
-
     http_instance = MagicMock()
-    http_instance.headers = {"content-length":12}
+    http_instance.headers = {"content-length": 12}
     mock_requests.return_value = http_instance
 
     try:
@@ -717,6 +745,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"},
@@ -768,10 +797,10 @@ def test_exists_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"CEPH not exists raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_exists_http_ok(mock_requests):
-
     http_instance = MagicMock()
     http_instance.status_code = 200
     mock_requests.return_value = http_instance
@@ -792,6 +821,7 @@ def test_exists_http_ok(mock_requests):
 
 ############ remove
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.remove")
 def test_remove_file_ok(mock_remove):
@@ -807,6 +837,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"},
@@ -832,6 +863,7 @@ def test_remove_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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"},
@@ -861,6 +893,7 @@ 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"},
@@ -881,6 +914,7 @@ def test_get_osgeo_path_nok():
     with pytest.raises(NotImplementedError):
         get_osgeo_path("ceph://pool/data.ext")
 
+
 ############ size_path
 def test_size_path_file_ok():
     try:
@@ -889,22 +923,31 @@ def test_size_path_file_ok():
     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) :
+    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)
-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,
+)
+def test_size_path_ceph_nok():
     with pytest.raises(NotImplementedError):
         size = size_path("ceph://pool/path")
 
-@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):
 
+@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}]}]
+    pages = [{"Contents": [{"Size": 10}, {"Size": 20}]}, {"Contents": [{"Size": 50}]}]
     paginator = MagicMock()
     paginator.paginate.return_value = pages
     client = MagicMock()
@@ -916,4 +959,3 @@ def test_size_path_s3_ok(mocked_s3_client):
         assert size == 80
     except Exception as exc:
         assert False, f"S3 size of the path raises an exception: {exc}"
-

From 175152bf6cf1f17fc71b0a8ba14d2d7895829c31 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 14:55:22 +0200
Subject: [PATCH 62/89] Move Pyramidtype to enums module

---
 src/rok4/Layer.py   | 3 ++-
 src/rok4/Pyramid.py | 9 +--------
 src/rok4/enums.py   | 7 +++++++
 tests/test_Layer.py | 2 +-
 4 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/rok4/Layer.py b/src/rok4/Layer.py
index 316a9ca..e57e3ab 100644
--- a/src/rok4/Layer.py
+++ b/src/rok4/Layer.py
@@ -12,10 +12,11 @@
 import re
 
 from rok4.Exceptions import *
-from rok4.Pyramid import Pyramid, PyramidType
+from rok4.Pyramid import Pyramid
 from rok4.TileMatrixSet import TileMatrixSet
 from rok4.Storage import *
 from rok4.Utils import *
+from rok4.enums import PyramidType
 
 
 class Layer:
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index fd01f1d..0d176d4 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -21,14 +21,7 @@
 from rok4.TileMatrixSet import TileMatrixSet, TileMatrix
 from rok4.Storage import *
 from rok4.Utils import *
-from rok4.enums import StorageType
-
-
-class PyramidType(Enum):
-    """Pyramid's data type"""
-
-    RASTER = "RASTER"
-    VECTOR = "VECTOR"
+from rok4.enums import PyramidType, StorageType
 
 
 class SlabType(Enum):
diff --git a/src/rok4/enums.py b/src/rok4/enums.py
index 2fca210..9a0a486 100644
--- a/src/rok4/enums.py
+++ b/src/rok4/enums.py
@@ -4,6 +4,13 @@
 from enum import Enum
 
 
+class PyramidType(Enum):
+    """Pyramid's data type"""
+
+    RASTER = "RASTER"
+    VECTOR = "VECTOR"
+
+
 class StorageType(Enum):
     """Matrice de correspondance entre type de stockage et protocole."""
 
diff --git a/tests/test_Layer.py b/tests/test_Layer.py
index 0a60d5c..7a3788e 100644
--- a/tests/test_Layer.py
+++ b/tests/test_Layer.py
@@ -1,5 +1,5 @@
 from rok4.Layer import Layer
-from rok4.Pyramid import PyramidType
+from rok4.enums import PyramidType
 from rok4.Exceptions import *
 
 import pytest

From 5672c878a517804a33eff3ad7abc9d924581219f Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 15:02:21 +0200
Subject: [PATCH 63/89] Move SlabType to enums module

---
 src/rok4/Pyramid.py   | 9 +--------
 src/rok4/enums.py     | 7 +++++++
 tests/test_Pyramid.py | 2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index 0d176d4..0d7e382 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -21,14 +21,7 @@
 from rok4.TileMatrixSet import TileMatrixSet, TileMatrix
 from rok4.Storage import *
 from rok4.Utils import *
-from rok4.enums import PyramidType, StorageType
-
-
-class SlabType(Enum):
-    """Slab's type"""
-
-    DATA = "DATA"  # Slab of data, raster or vector
-    MASK = "MASK"  # Slab of mask, only for raster pyramid, image with one band : 0 is nodata, other values are data
+from rok4.enums import PyramidType, SlabType, StorageType
 
 
 ROK4_IMAGE_HEADER_SIZE = 2048
diff --git a/src/rok4/enums.py b/src/rok4/enums.py
index 9a0a486..76300ce 100644
--- a/src/rok4/enums.py
+++ b/src/rok4/enums.py
@@ -11,6 +11,13 @@ class PyramidType(Enum):
     VECTOR = "VECTOR"
 
 
+class SlabType(Enum):
+    """Slab's type"""
+
+    DATA = "DATA"  # Slab of data, raster or vector
+    MASK = "MASK"  # Slab of mask, only for raster pyramid, image with one band : 0 is nodata, other values are data
+
+
 class StorageType(Enum):
     """Matrice de correspondance entre type de stockage et protocole."""
 
diff --git a/tests/test_Pyramid.py b/tests/test_Pyramid.py
index d72ce2f..60576f3 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_Pyramid.py
@@ -1,6 +1,6 @@
 from rok4.Pyramid import *
 from rok4.TileMatrixSet import TileMatrixSet
-from rok4.enums import StorageType
+from rok4.enums import SlabType, StorageType
 from rok4.Utils import *
 from rok4.Exceptions import *
 

From 726a18dfb4bacbfb919e9c7dbbc182e13b66afff Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 15:12:11 +0200
Subject: [PATCH 64/89] Rm unused ColorFormat

---
 src/rok4/Utils.py | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/src/rok4/Utils.py b/src/rok4/Utils.py
index da15aef..627686c 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/Utils.py
@@ -6,25 +6,12 @@
 
 from typing import Dict, List, Tuple, Union
 from osgeo import ogr, osr, gdal
-from enum import Enum
 
 ogr.UseExceptions()
 osr.UseExceptions()
 gdal.UseExceptions()
 
 
-class ColorFormat(Enum):
-    """A color format enumeration.
-    Except from "BIT", the member's name matches
-      a common variable format name. The member's value is
-      the allocated bit size associated to this format.
-    """
-
-    BIT = 1
-    UINT8 = 8
-    FLOAT32 = 32
-
-
 __SR_BOOK = {}
 
 

From 48fb66a586f56e6a0edb5127cfd503797d53965e Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 18 Jul 2023 12:50:35 +0200
Subject: [PATCH 65/89] Rename files to comply with Python convention PEP8

---
 README.md                                     |    4 +-
 README.pypi.md                                |    2 +-
 src/rok4/Pyramid.py                           |   79 +-
 src/rok4/enums.py                             |   13 +-
 src/rok4/{Exceptions.py => exceptions.py}     |    0
 src/rok4/{Layer.py => layer.py}               |   22 +-
 src/rok4/pyramid.py                           | 1373 +++++++++++++++++
 src/rok4/{Raster.py => raster.py}             |   13 +-
 src/rok4/{Storage.py => storage.py}           |  112 +-
 .../{TileMatrixSet.py => tile_matrix_set.py}  |   10 +-
 src/rok4/{Utils.py => utils.py}               |    1 +
 src/rok4/{Vector.py => vector.py}             |   11 +-
 tests/{test_Layer.py => test_layer.py}        |   28 +-
 tests/{test_Pyramid.py => test_pyramid.py}    |   53 +-
 tests/{test_Raster.py => test_raster.py}      |   78 +-
 tests/{test_Storage.py => test_storage.py}    |  187 +--
 ...leMatrixSet.py => test_tile_matrix_set.py} |   36 +-
 tests/{test_Utils.py => test_utils.py}        |   59 +-
 tests/{test_Vector.py => test_vector.py}      |   21 +-
 19 files changed, 1724 insertions(+), 378 deletions(-)
 rename src/rok4/{Exceptions.py => exceptions.py} (100%)
 rename src/rok4/{Layer.py => layer.py} (96%)
 create mode 100644 src/rok4/pyramid.py
 rename src/rok4/{Raster.py => raster.py} (97%)
 rename src/rok4/{Storage.py => storage.py} (94%)
 rename src/rok4/{TileMatrixSet.py => tile_matrix_set.py} (98%)
 rename src/rok4/{Utils.py => utils.py} (99%)
 rename src/rok4/{Vector.py => vector.py} (98%)
 rename tests/{test_Layer.py => test_layer.py} (91%)
 rename tests/{test_Pyramid.py => test_pyramid.py} (92%)
 rename tests/{test_Raster.py => test_raster.py} (91%)
 rename tests/{test_Storage.py => test_storage.py} (90%)
 rename tests/{test_TileMatrixSet.py => test_tile_matrix_set.py} (93%)
 rename tests/{test_Utils.py => test_utils.py} (90%)
 rename tests/{test_Vector.py => test_vector.py} (92%)

diff --git a/README.md b/README.md
index 29bf082..2117b06 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ L'environnement d'exécution doit avoir accès aux librairies système. Dans le
 ## Utiliser la librairie
 
 ```python
-from rok4.TileMatrixSet import TileMatrixSet
+from rok4.tile_matrix_set import TileMatrixSet
 
 try:
     tms = TileMatrixSet("file:///path/to/tms.json")
@@ -34,7 +34,7 @@ Plus d'exemple dans la documentation développeur.
 * Installer les dépendances de développement :
 
     ```sh
-    python3 -m pip install -e[dev]
+    python3 -m pip install -e .[dev]
     ```
 
 * Consulter les [directives de contribution](./CONTRIBUTING.md)
diff --git a/README.pypi.md b/README.pypi.md
index fc3417b..d5e9d1a 100644
--- a/README.pypi.md
+++ b/README.pypi.md
@@ -16,7 +16,7 @@ The `rok4` package is available on :
 ## Usage
 
 ```python
-from rok4.TileMatrixSet import TileMatrixSet
+from rok4.tile_matrix_set import TileMatrixSet
 
 try:
     tms = TileMatrixSet("file:///path/to/tms.json")
diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
index f6c670f..19fa9c7 100644
--- a/src/rok4/Pyramid.py
+++ b/src/rok4/Pyramid.py
@@ -6,23 +6,36 @@
 - `Level` - Level of a pyramid
 """
 
-import io
+from typing import Dict, List, Tuple, Union, Iterator
 import json
+from json.decoder import JSONDecodeError
 import os
 import re
+import numpy
 import zlib
-from json.decoder import JSONDecodeError
-from typing import Dict, Iterator, List, Tuple, Union
-
+import io
 import mapbox_vector_tile
-import numpy
 from PIL import Image
 
 from rok4.Exceptions import *
-from rok4.Storage import *
-from rok4.TileMatrixSet import TileMatrix, TileMatrixSet
-from rok4.Utils import *
-from rok4.enums import PyramidType, SlabType, StorageType
+from rok4.tile_matrix_set import TileMatrixSet, TileMatrix
+from rok4.storage import *
+from rok4.utils import *
+from rok4.enums import StorageType
+
+
+class PyramidType(Enum):
+    """Pyramid's data type"""
+
+    RASTER = "RASTER"
+    VECTOR = "VECTOR"
+
+
+class SlabType(Enum):
+    """Slab's type"""
+
+    DATA = "DATA"  # Slab of data, raster or vector
+    MASK = "MASK"  # Slab of mask, only for raster pyramid, image with one band : 0 is nodata, other values are data
 
 
 ROK4_IMAGE_HEADER_SIZE = 2048
@@ -360,10 +373,10 @@ class Pyramid:
         __name (str): pyramid's name
         __descriptor (str): pyramid's descriptor path
         __list (str): pyramid's list path
-        __tms (rok4.TileMatrixSet.TileMatrixSet): Used grid
+        __tms (rok4.tile_matrix_set.TileMatrixSet): Used grid
         __levels (Dict[str, Level]): Pyramid's levels
         __format (str): Data format
-        __storage (Dict[str, Union[rok4.Storage.StorageType,str,int]]): Pyramid's storage informations (type, root and depth if FILE storage)
+        __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).
 
@@ -400,7 +413,7 @@ def from_descriptor(cls, descriptor: str) -> "Pyramid":
 
             S3 stored descriptor
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
@@ -537,8 +550,11 @@ def serializable(self) -> Dict:
         Returns:
             Dict: descriptor structured object description
         """
-
-        serialization = {"tile_matrix_set": self.__tms.name, "format": self.__format}
+        
+        serialization = {
+            "tile_matrix_set": self.__tms.name,
+            "format": self.__format
+        }
 
         serialization["levels"] = []
         sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
@@ -605,7 +621,7 @@ def storage_root(self) -> str:
         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
@@ -655,6 +671,7 @@ def format(self) -> str:
 
     @property
     def tile_extension(self) -> str:
+
         if self.__format in [
             "TIFF_RAW_UINT8",
             "TIFF_LZW_UINT8",
@@ -729,7 +746,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType, str, int, int], Dict]
 
             S3 stored descriptor
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
@@ -769,7 +786,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType, str, int, int], Dict]
             roots = {}
             s3_cluster = self.storage_s3_cluster
 
-            with open(list_file) as listin:
+            with open(list_file, "r") as listin:
                 # Lecture des racines
                 for line in listin:
                     line = line.rstrip()
@@ -819,7 +836,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)
 
     def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
@@ -836,7 +853,7 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
 
             All levels
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
@@ -847,7 +864,7 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
 
             From pyramid's bottom to provided top (level 5)
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
@@ -918,7 +935,7 @@ def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
 
             FILE stored pyramid
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("/path/to/descriptor.json")
@@ -929,7 +946,7 @@ def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
 
             S3 stored pyramid
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/pyramid.json")
@@ -1003,6 +1020,7 @@ def get_slab_path_from_infos(
         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
 
@@ -1023,7 +1041,7 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
 
             FILE stored raster pyramid, to extract a tile containing a point and save it as independent image
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("/data/pyramids/SCAN1000.json")
@@ -1135,7 +1153,7 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
 
             FILE stored DTM (raster) pyramid, to get the altitude value at a point in the best level
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("/data/pyramids/RGEALTI.json")
@@ -1165,6 +1183,7 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
         level_object = self.get_level(level)
 
         if self.__format == "TIFF_JPG_UINT8" or self.__format == "TIFF_JPG90_UINT8":
+
             try:
                 img = Image.open(io.BytesIO(binary_tile))
             except Exception as e:
@@ -1246,7 +1265,7 @@ def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
 
             S3 stored vector pyramid, to print a tile as GeoJSON
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
                 import json
 
                 try:
@@ -1307,7 +1326,7 @@ def get_tile_indices(
 
             FILE stored DTM (raster) pyramid, to get the altitude value at a point in the best level
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("/data/pyramids/RGEALTI.json")
@@ -1349,7 +1368,7 @@ def size(self) -> int:
 
         Examples:
 
-                from rok4.Pyramid import Pyramid
+                from rok4.pyramid import Pyramid
 
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
@@ -1361,8 +1380,6 @@ def size(self) -> int:
         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)
-            )
+        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/enums.py b/src/rok4/enums.py
index 76300ce..861464f 100644
--- a/src/rok4/enums.py
+++ b/src/rok4/enums.py
@@ -19,10 +19,21 @@ class SlabType(Enum):
 
 
 class StorageType(Enum):
-    """Matrice de correspondance entre type de stockage et protocole."""
+    """Storage type and path's protocol"""
 
     CEPH = "ceph://"
     FILE = "file://"
     HTTP = "http://"
     HTTPS = "https://"
     S3 = "s3://"
+
+class ColorFormat(Enum):
+    """A color format enumeration.
+    Except from "BIT", the member's name matches
+      a common variable format name. The member's value is
+      the allocated bit size associated to this format.
+    """
+
+    BIT = 1
+    UINT8 = 8
+    FLOAT32 = 32
\ No newline at end of file
diff --git a/src/rok4/Exceptions.py b/src/rok4/exceptions.py
similarity index 100%
rename from src/rok4/Exceptions.py
rename to src/rok4/exceptions.py
diff --git a/src/rok4/Layer.py b/src/rok4/layer.py
similarity index 96%
rename from src/rok4/Layer.py
rename to src/rok4/layer.py
index b13e55a..ba2f211 100644
--- a/src/rok4/Layer.py
+++ b/src/rok4/layer.py
@@ -5,17 +5,17 @@
 - `Layer` - Descriptor to broadcast pyramids' data
 """
 
+from typing import Dict, List, Tuple, Union
 import json
+from json.decoder import JSONDecodeError
 import os
 import re
-from json.decoder import JSONDecodeError
-from typing import Dict, List, Tuple, Union
 
-from rok4.Exceptions import *
-from rok4.Pyramid import Pyramid
-from rok4.TileMatrixSet import TileMatrixSet
-from rok4.Storage import *
-from rok4.Utils import *
+from rok4.exceptions import *
+from rok4.pyramid import Pyramid, PyramidType
+from rok4.tile_matrix_set import TileMatrixSet
+from rok4.storage import *
+from rok4.utils import *
 from rok4.enums import PyramidType
 
 
@@ -24,12 +24,12 @@ class Layer:
 
     Attributes:
         __name (str): layer's technical name
-        __pyramids (Dict[str, Union[rok4.Pyramid.Pyramid,str,str]]): used pyramids
+        __pyramids (Dict[str, Union[rok4.pyramid.Pyramid,str,str]]): used pyramids
         __format (str): pyramid's list path
-        __tms (rok4.TileMatrixSet.TileMatrixSet): Used grid
+        __tms (rok4.tile_matrix_set.TileMatrixSet): Used grid
         __keywords (List[str]): Keywords
-        __levels (Dict[str, rok4.Pyramid.Level]): Used pyramids' levels
-        __best_level (rok4.Pyramid.Level): Used pyramids best level
+        __levels (Dict[str, rok4.pyramid.Level]): Used pyramids' levels
+        __best_level (rok4.pyramid.Level): Used pyramids best level
         __resampling (str): Interpolation to use fot resampling
         __bbox (Tuple[float, float, float, float]): data bounding box, TMS coordinates system
         __geobbox (Tuple[float, float, float, float]): data bounding box, EPSG:4326
diff --git a/src/rok4/pyramid.py b/src/rok4/pyramid.py
new file mode 100644
index 0000000..6c83f0e
--- /dev/null
+++ b/src/rok4/pyramid.py
@@ -0,0 +1,1373 @@
+"""Provide classes to use pyramid's data.
+
+The module contains the following classes:
+
+- `Pyramid` - Data container
+- `Level` - Level of a pyramid
+"""
+
+from typing import Dict, List, Tuple, Union, Iterator
+import json
+from json.decoder import JSONDecodeError
+import os
+import re
+import numpy
+import zlib
+import io
+import mapbox_vector_tile
+from PIL import Image
+
+from rok4.exceptions import *
+from rok4.tile_matrix_set import TileMatrixSet, TileMatrix
+from rok4.storage import *
+from rok4.utils import *
+
+
+from rok4.enums import PyramidType, SlabType, StorageType
+
+
+ROK4_IMAGE_HEADER_SIZE = 2048
+"""Slab's header size, 2048 bytes"""
+
+
+def b36_number_encode(number: int) -> str:
+    """Convert base-10 number to base-36
+
+    Used alphabet is '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+    Args:
+        number (int): base-10 number
+
+    Returns:
+        str: base-36 number
+    """
+
+    alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+    base36 = ""
+
+    if 0 <= number < len(alphabet):
+        return alphabet[number]
+
+    while number != 0:
+        number, i = divmod(number, len(alphabet))
+        base36 = alphabet[i] + base36
+
+    return base36
+
+
+def b36_number_decode(number: str) -> int:
+    """Convert base-36 number to base-10
+
+    Args:
+        number (str): base-36 number
+
+    Returns:
+        int: base-10 number
+    """
+    return int(number, 36)
+
+
+def b36_path_decode(path: str) -> Tuple[int, int]:
+    """Get slab's column and row from a base-36 based path
+
+    Args:
+        path (str): slab's path
+
+    Returns:
+        Tuple[int, int]: slab's column and row
+    """
+
+    path = path.replace("/", "")
+    path = re.sub(r"(\.TIFF?)", "", path.upper())
+
+    b36_column = ""
+    b36_row = ""
+
+    while len(path) > 0:
+        b36_column += path[0]
+        b36_row += path[1]
+        path = path[2:]
+
+    return b36_number_decode(b36_column), b36_number_decode(b36_row)
+
+
+def b36_path_encode(column: int, row: int, slashs: int) -> str:
+    """Convert slab indices to base-36 based path, with .tif extension
+
+    Args:
+        column (int): slab's column
+        row (int): slab's row
+        slashs (int): slashs' number (to split path)
+
+    Returns:
+        str: base-36 based path
+    """
+
+    b36_column = b36_number_encode(column)
+    b36_row = b36_number_encode(row)
+
+    max_len = max(slashs + 1, len(b36_column), len(b36_row))
+
+    b36_column = b36_column.rjust(max_len, "0")
+    b36_row = b36_row.rjust(max_len, "0")
+
+    b36_path = ""
+
+    while len(b36_column) > 0:
+        b36_path = b36_row[-1] + b36_path
+        b36_path = b36_column[-1] + b36_path
+
+        b36_column = b36_column[:-1]
+        b36_row = b36_row[:-1]
+
+        if slashs > 0:
+            b36_path = "/" + b36_path
+            slashs -= 1
+
+    return f"{b36_path}.tif"
+
+
+class Level:
+    """A pyramid's level, raster or vector
+
+    Attributes:
+        __id (str): level's identifier. have to exist in the pyramid's used TMS
+        __tile_limits (Dict[str, int]): minimum and maximum tiles' columns and rows of pyramid's content
+        __slab_size (Tuple[int, int]): number of tile in a slab, widthwise and heightwise
+        __tables (List[Dict]): for a VECTOR pyramid, description of vector content, tables and attributes
+    """
+
+    @classmethod
+    def from_descriptor(cls, data: Dict, pyramid: "Pyramid") -> "Level":
+        """Create a pyramid's level from the pyramid's descriptor levels element
+
+        Args:
+            data (Dict): level's information from the pyramid's descriptor
+            pyramid (Pyramid): pyramid containing the level to create
+
+        Raises:
+            Exception: different storage or masks presence between the level and the pyramid
+            MissingAttributeError: Attribute is missing in the content
+
+        Returns:
+            Pyramid: a Level instance
+        """
+        level = cls()
+
+        level.__pyramid = pyramid
+
+        # Attributs communs
+        try:
+            level.__id = data["id"]
+            level.__tile_limits = data["tile_limits"]
+            level.__slab_size = (
+                data["tiles_per_width"],
+                data["tiles_per_height"],
+            )
+
+            # Informations sur le stockage : on les valide et stocke dans la pyramide
+            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 "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"
+                    )
+            else:
+                if pyramid.own_masks:
+                    raise Exception(
+                        f"Pyramid {pyramid.__descriptor} define a mask format but level {level.__id} does not define mask storage informations"
+                    )
+
+        except KeyError as e:
+            raise MissingAttributeError(pyramid.descriptor, f"levels[].{e}")
+
+        # Attributs dans le cas d'un niveau vecteur
+        if level.__pyramid.type == PyramidType.VECTOR:
+            try:
+                level.__tables = data["tables"]
+
+            except KeyError as e:
+                raise MissingAttributeError(pyramid.descriptor, f"levels[].{e}")
+
+        return level
+
+    @classmethod
+    def from_other(cls, other: "Level", pyramid: "Pyramid") -> "Level":
+        """Create a pyramid's level from another one
+
+        Args:
+            other (Level): level to clone
+            pyramid (Pyramid): new pyramid containing the new level
+
+        Raises:
+            Exception: different storage or masks presence between the level and the pyramid
+            MissingAttributeError: Attribute is missing in the content
+
+        Returns:
+            Pyramid: a Level instance
+        """
+
+        level = cls()
+
+        # Attributs communs
+        level.__id = other.__id
+        level.__pyramid = pyramid
+        level.__tile_limits = other.__tile_limits
+        level.__slab_size = other.__slab_size
+
+        # Attributs dans le cas d'un niveau vecteur
+        if level.__pyramid.type == PyramidType.VECTOR:
+            level.__tables = other.__tables
+
+        return level
+
+    def __str__(self) -> str:
+        return f"{self.__pyramid.type.name} pyramid's level '{self.__id}' ({self.__pyramid.storage_type.name} storage)"
+
+    @property
+    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],
+            "tiles_per_height": self.__slab_size[1],
+            "tile_limits": self.__tile_limits,
+        }
+
+        if self.__pyramid.type == PyramidType.VECTOR:
+            serialization["tables"] = self.__tables
+
+        if self.__pyramid.storage_type == StorageType.FILE:
+            serialization["storage"] = {
+                "type": "FILE",
+                "image_directory": f"{self.__pyramid.name}/DATA/{self.__id}",
+                "path_depth": self.__pyramid.storage_depth,
+            }
+            if self.__pyramid.own_masks:
+                serialization["storage"][
+                    "mask_directory"
+                ] = f"{self.__pyramid.name}/MASK/{self.__id}"
+
+        elif self.__pyramid.storage_type == StorageType.CEPH:
+            serialization["storage"] = {
+                "type": "CEPH",
+                "image_prefix": f"{self.__pyramid.name}/DATA_{self.__id}",
+                "pool_name": self.__pyramid.storage_root,
+            }
+            if self.__pyramid.own_masks:
+                serialization["storage"]["mask_prefix"] = f"{self.__pyramid.name}/MASK_{self.__id}"
+
+        elif self.__pyramid.storage_type == StorageType.S3:
+            serialization["storage"] = {
+                "type": "S3",
+                "image_prefix": f"{self.__pyramid.name}/DATA_{self.__id}",
+                "bucket_name": self.__pyramid.storage_root,
+            }
+            if self.__pyramid.own_masks:
+                serialization["storage"]["mask_prefix"] = f"{self.__pyramid.name}/MASK_{self.__id}"
+
+        return serialization
+
+    @property
+    def id(self) -> str:
+        return self.__id
+
+    @property
+    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"]
+        )
+        max_bbox = self.__pyramid.tms.get_level(self.__id).tile_to_bbox(
+            self.__tile_limits["max_col"], self.__tile_limits["min_row"]
+        )
+
+        return (min_bbox[0], min_bbox[1], max_bbox[2], max_bbox[3])
+
+    @property
+    def resolution(self) -> str:
+        return self.__pyramid.tms.get_level(self.__id).resolution
+
+    @property
+    def tile_matrix(self) -> TileMatrix:
+        return self.__pyramid.tms.get_level(self.__id)
+
+    @property
+    def slab_width(self) -> int:
+        return self.__slab_size[0]
+
+    @property
+    def slab_height(self) -> int:
+        return self.__slab_size[1]
+
+    def is_in_limits(self, column: int, row: int) -> bool:
+        """Is the tile indices in limits ?
+
+        Args:
+            column (int): tile's column
+            row (int): tile's row
+
+        Returns:
+            bool: True if tiles' limits contain the provided tile's indices
+        """
+        return (
+            self.__tile_limits["min_row"] <= row
+            and self.__tile_limits["max_row"] >= row
+            and self.__tile_limits["min_col"] <= column
+            and self.__tile_limits["max_col"] >= column
+        )
+
+    def set_limits_from_bbox(self, bbox: Tuple[float, float, float, float]) -> None:
+        """Set tile limits, based on provided bounding box
+
+        Args:
+            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,
+            "max_col": col_max,
+            "max_row": row_max,
+            "min_col": col_min,
+        }
+
+
+class Pyramid:
+
+    """A data pyramid, raster or vector
+
+    Attributes:
+        __name (str): pyramid's name
+        __descriptor (str): pyramid's descriptor path
+        __list (str): pyramid's list path
+        __tms (rok4.tile_matrix_set.TileMatrixSet): Used grid
+        __levels (Dict[str, Level]): Pyramid's levels
+        __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).
+
+            Example (S3 storage):
+
+                {
+                    'cache': {
+                        (<SlabType.DATA: 'DATA'>, '18', 5424, 7526): {
+                            'link': False,
+                            'md5': None,
+                            'root': 'pyramids@localhost:9000/LIMADM',
+                            'slab': 'DATA_18_5424_7526'
+                        }
+                    },
+                    'loaded': True
+                }
+    """
+
+    @classmethod
+    def from_descriptor(cls, descriptor: str) -> "Pyramid":
+        """Create a pyramid from its descriptor
+
+        Args:
+            descriptor (str): pyramid's descriptor path
+
+        Raises:
+            FormatError: Provided path or the TMS is not a well formed JSON
+            Exception: Level issue : no one in the pyramid or the used TMS, or level ID not defined in the TMS
+            MissingAttributeError: Attribute is missing in the content
+            StorageError: Storage read issue (pyramid descriptor or TMS)
+            MissingEnvironmentError: Missing object storage informations or TMS root directory
+
+        Examples:
+
+            S3 stored descriptor
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor")
+
+        Returns:
+            Pyramid: a Pyramid instance
+        """
+        try:
+            data = json.loads(get_data_str(descriptor))
+
+        except JSONDecodeError as e:
+            raise FormatError("JSON", descriptor, e)
+
+        pyramid = cls()
+
+        pyramid.__storage["type"], path, pyramid.__storage["root"], base_name = get_infos_from_path(
+            descriptor
+        )
+        pyramid.__name = base_name[:-5]  # on supprime l'extension.json
+        pyramid.__descriptor = descriptor
+        pyramid.__list = get_path_from_infos(
+            pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.list"
+        )
+
+        try:
+            # Attributs communs
+            pyramid.__tms = TileMatrixSet(data["tile_matrix_set"])
+            pyramid.__format = data["format"]
+
+            # Attributs d'une pyramide raster
+            if pyramid.type == PyramidType.RASTER:
+                pyramid.__raster_specifications = data["raster_specifications"]
+
+                if "mask_format" in data:
+                    pyramid.__masks = True
+                else:
+                    pyramid.__masks = False
+
+            # Niveaux
+            for l in data["levels"]:
+                lev = Level.from_descriptor(l, pyramid)
+                pyramid.__levels[lev.id] = lev
+
+                if pyramid.__tms.get_level(lev.id) is None:
+                    raise Exception(
+                        f"Pyramid {descriptor} owns a level with the ID '{lev.id}', not defined in the TMS '{pyramid.tms.name}'"
+                    )
+
+        except KeyError as e:
+            raise MissingAttributeError(descriptor, e)
+
+        if len(pyramid.__levels.keys()) == 0:
+            raise Exception(f"Pyramid '{descriptor}' has no level")
+
+        return pyramid
+
+    @classmethod
+    def from_other(cls, other: "Pyramid", name: str, storage: Dict) -> "Pyramid":
+        """Create a pyramid from another one
+
+        Args:
+            other (Pyramid): pyramid to clone
+            name (str): new pyramid's name
+            storage (Dict[str, Union[str, int]]): new pyramid's storage informations
+
+        Raises:
+            FormatError: Provided path or the TMS is not a well formed JSON
+            Exception: Level issue : no one in the pyramid or the used TMS, or level ID not defined in the TMS
+            MissingAttributeError: Attribute is missing in the content
+
+        Returns:
+            Pyramid: a Pyramid instance
+        """
+        try:
+            # On convertit le type de stockage selon l'énumération
+            storage["type"] = StorageType[storage["type"]]
+
+            if storage["type"] == StorageType.FILE and name.find("/") != -1:
+                raise Exception(f"A FILE stored pyramid's name cannot contain '/' : '{name}'")
+
+            if storage["type"] == StorageType.FILE and "depth" not in storage:
+                storage["depth"] = 2
+
+            pyramid = cls()
+
+            # Attributs communs
+            pyramid.__name = name
+            pyramid.__storage = storage
+            pyramid.__masks = other.__masks
+
+            pyramid.__descriptor = get_path_from_infos(
+                pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.json"
+            )
+            pyramid.__list = get_path_from_infos(
+                pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.list"
+            )
+            pyramid.__tms = other.__tms
+            pyramid.__format = other.__format
+
+            # Attributs d'une pyramide raster
+            if pyramid.type == PyramidType.RASTER:
+                if other.own_masks:
+                    pyramid.__masks = True
+                else:
+                    pyramid.__masks = False
+                pyramid.__raster_specifications = other.__raster_specifications
+
+            # Niveaux
+            for l in other.__levels.values():
+                lev = Level.from_other(l, pyramid)
+                pyramid.__levels[lev.id] = lev
+
+        except KeyError as e:
+            raise MissingAttributeError(descriptor, e)
+
+        return pyramid
+
+    def __init__(self) -> None:
+        self.__storage = {}
+        self.__levels = {}
+        self.__masks = None
+
+        self.__content = {"loaded": False, "cache": {}}
+
+    def __str__(self) -> str:
+        return f"{self.type.name} pyramid '{self.__name}' ({self.__storage['type'].name} storage)"
+
+    @property
+    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
+        }
+
+        serialization["levels"] = []
+        sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
+
+        for l in sorted_levels:
+            serialization["levels"].append(l.serializable)
+
+        if self.type == PyramidType.RASTER:
+            serialization["raster_specifications"] = self.__raster_specifications
+
+        if self.__masks:
+            serialization["mask_format"] = "TIFF_ZIP_UINT8"
+
+        return serialization
+
+    @property
+    def list(self) -> str:
+        return self.__list
+
+    @property
+    def descriptor(self) -> str:
+        return self.__descriptor
+
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    @property
+    def tms(self) -> TileMatrixSet:
+        return self.__tms
+
+    @property
+    def raster_specifications(self) -> Dict:
+        """Get raster specifications for a RASTER pyramid
+
+        Example:
+            {
+                "channels": 3,
+                "nodata": "255,0,0",
+                "photometric": "rgb",
+                "interpolation": "bicubic"
+            }
+
+        Returns:
+            Dict: Raster specifications, None if VECTOR pyramid
+        """
+        return self.__raster_specifications
+
+    @property
+    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:
+        """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:
+        return self.__storage.get("depth", None)
+
+    @property
+    def storage_s3_cluster(self) -> str:
+        """Get the pyramid's storage S3 cluster (host name)
+
+        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]
+            except IndexError:
+                return None
+        else:
+            return None
+
+    @storage_depth.setter
+    def storage_depth(self, d: int) -> None:
+        """Set the tree depth for a FILE storage
+
+        Args:
+            d (int): file storage depth
+
+        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
+
+    @property
+    def own_masks(self) -> bool:
+        return self.__masks
+
+    @property
+    def format(self) -> str:
+        return self.__format
+
+    @property
+    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"]:
+            return "jpg"
+        elif self.__format == "TIFF_PNG_UINT8":
+            return "png"
+        elif self.__format == "TIFF_PBF_MVT":
+            return "pbf"
+        else:
+            raise Exception(
+                f"Unknown pyramid's format ({self.__format}), cannot return the tile extension"
+            )
+
+    @property
+    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
+    def top_level(self) -> "Level":
+        """Get the low resolution level in the pyramid
+
+        Returns:
+            Level: the top level
+        """
+        return sorted(self.__levels.values(), key=lambda l: l.resolution)[-1]
+
+    @property
+    def type(self) -> PyramidType:
+        """Get the pyramid's type (RASTER or VECTOR) from its format
+
+        Returns:
+            PyramidType: RASTER or VECTOR
+        """
+        if self.__format == "TIFF_PBF_MVT":
+            return PyramidType.VECTOR
+        else:
+            return PyramidType.RASTER
+
+    def load_list(self) -> None:
+        """Load list content and cache it
+
+        If list is already loaded, nothing done
+        """
+        if self.__content["loaded"]:
+            return
+
+        for slab, infos in self.list_generator():
+            self.__content["cache"][slab] = infos
+
+        self.__content["loaded"] = True
+
+    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
+
+        Examples:
+
+            S3 stored descriptor
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+
+                    for (slab_type, level, column, row), infos in pyramid.list_generator():
+                        print(infos)
+
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and read the list")
+
+        Yields:
+            Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]: Slab indices and storage informations
+
+            Value example:
+
+                (
+                    (<SlabType.DATA: 'DATA'>, '18', 5424, 7526),
+                    {
+                        'link': False,
+                        'md5': None,
+                        'root': 'pyramids@localhost:9000/LIMADM',
+                        'slab': 'DATA_18_5424_7526'
+                    }
+                )
+
+        """
+        if self.__content["loaded"]:
+            for slab, infos in self.__content["cache"].items():
+                yield slab, infos
+        else:
+            # Copie de la liste dans un fichier temporaire (cette liste peut être un objet)
+            list_obj = tempfile.NamedTemporaryFile(mode="r", delete=False)
+            list_file = list_obj.name
+            copy(self.__list, f"file://{list_file}")
+            list_obj.close()
+
+            roots = {}
+            s3_cluster = self.storage_s3_cluster
+
+            with open(list_file, "r") as listin:
+                # Lecture des racines
+                for line in listin:
+                    line = line.rstrip()
+
+                    if line == "#":
+                        break
+
+                    root_id, root_path = line.split("=", 1)
+
+                    if s3_cluster is None:
+                        roots[root_id] = root_path
+                    else:
+                        # On a un nom de cluster S3, on l'ajoute au nom du bucket dans les racines
+                        root_bucket, root_path = root_path.split("/", 1)
+                        roots[root_id] = f"{root_bucket}@{s3_cluster}/{root_path}"
+
+                # Lecture des dalles
+                for line in listin:
+                    line = line.rstrip()
+
+                    parts = line.split(" ", 1)
+                    slab_path = parts[0]
+                    slab_md5 = None
+                    if len(parts) == 2:
+                        slab_md5 = parts[1]
+
+                    root_id, slab_path = slab_path.split("/", 1)
+
+                    slab_type, level, column, row = self.get_infos_from_slab_path(slab_path)
+                    infos = {
+                        "root": roots[root_id],
+                        "link": root_id != "0",
+                        "slab": slab_path,
+                        "md5": slab_md5,
+                    }
+
+                    yield ((slab_type, level, column, row), infos)
+
+            remove(f"file://{list_file}")
+
+    def get_level(self, level_id: str) -> "Level":
+        """Get one level according to its identifier
+
+        Args:
+            level_id: Level identifier
+
+        Returns:
+            The corresponding pyramid's level, None if not present
+        """
+        
+        return self.__levels.get(level_id, None)
+
+    def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
+        """Get sorted levels in the provided range from bottom to top
+
+        Args:
+            bottom_id (str, optionnal): specific bottom level id. Defaults to None.
+            top_id (str, optionnal): specific top level id. Defaults to None.
+
+        Raises:
+            Exception: Provided levels are not consistent (bottom > top or not in the pyramid)
+
+        Examples:
+
+            All levels
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+                    levels = pyramid.get_levels()
+
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and get levels")
+
+            From pyramid's bottom to provided top (level 5)
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+                    levels = pyramid.get_levels(None, "5")
+
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and get levels")
+
+        Returns:
+            List[Level]: asked sorted levels
+        """
+
+        sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution)
+
+        levels = []
+
+        begin = False
+        if bottom_id is None:
+            # Pas de niveau du bas fourni, on commence tout en bas
+            begin = True
+        else:
+            if self.get_level(bottom_id) is None:
+                raise Exception(
+                    f"Pyramid {self.name} does not contain the provided bottom level {bottom_id}"
+                )
+
+        if top_id is not None and self.get_level(top_id) is None:
+            raise Exception(f"Pyramid {self.name} does not contain the provided top level {top_id}")
+
+        end = False
+
+        for l in sorted_levels:
+            if not begin and l.id == bottom_id:
+                begin = True
+
+            if begin:
+                levels.append(l)
+                if top_id is not None and l.id == top_id:
+                    end = True
+                    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)
+
+    def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
+        """Get the slab's indices from its storage path
+
+        Args:
+            path (str): Slab's storage path
+
+        Examples:
+
+            FILE stored pyramid
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("/path/to/descriptor.json")
+                    slab_type, level, column, row = self.get_infos_from_slab_path("DATA/12/00/4A/F7.tif")
+                    # (SlabType.DATA, "12", 159, 367)
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and convert a slab path")
+
+            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")
+                    # (SlabType.MASK, "15", 9164, 5846)
+                except Exception as e:
+                    print("Cannot load the pyramid from its descriptor and convert a slab path")
+
+        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("/")
+
+            # Le partie du chemin qui contient la colonne et ligne de la dalle est à la fin, en fonction de la profondeur choisie
+            # depth = 2 -> on doit utiliser les 3 dernières parties pour la conversion
+            column, row = b36_path_decode("/".join(parts[-(self.__storage["depth"] + 1) :]))
+            level = parts[-(self.__storage["depth"] + 2)]
+            raw_slab_type = parts[-(self.__storage["depth"] + 3)]
+
+            # Pour être retro compatible avec l'ancien nommage
+            if raw_slab_type == "IMAGE":
+                raw_slab_type = "DATA"
+
+            slab_type = SlabType[raw_slab_type]
+
+            return slab_type, level, column, row
+        else:
+            parts = re.split(r"[/_]", path)
+            column = parts[-2]
+            row = parts[-1]
+            level = parts[-3]
+            raw_slab_type = parts[-4]
+
+            # Pour être retro compatible avec l'ancien nommage
+            if raw_slab_type == "IMG":
+                raw_slab_type = "DATA"
+            elif raw_slab_type == "MSK":
+                raw_slab_type = "MASK"
+
+            slab_type = SlabType[raw_slab_type]
+
+            return slab_type, level, int(column), int(row)
+
+    def get_slab_path_from_infos(
+        self, slab_type: SlabType, level: str, column: int, row: int, full: bool = True
+    ) -> str:
+        """Get slab's storage path from the indices
+
+        Args:
+            slab_type (SlabType): DATA or MASK
+            level (str): Level identifier
+            column (int): Slab's column
+            row (int): Slab's row
+            full (bool, optional): Full path or just relative path from pyramid storage root. Defaults to True.
+
+        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
+
+        To get a tile, 3 steps :
+            * calculate slab path from tile index
+            * read slab index to get offsets and sizes of slab's tiles
+            * read the tile into the slab
+
+        Args:
+            level (str): Tile's level
+            column (int): Tile's column
+            row (int): Tile's row
+
+        Limitations:
+            Pyramids with one-tile slab are not handled
+
+        Examples:
+
+            FILE stored raster pyramid, to extract a tile containing a point and save it as independent image
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("/data/pyramids/SCAN1000.json")
+                    level, col, row, pcol, prow = pyramid.get_tile_indices(992904.46, 6733643.15, "9", srs = "IGNF:LAMB93")
+                    data = pyramid.get_tile_data_binary(level, col, row)
+
+                    if data is None:
+                        print("No data")
+                    else:
+                        tile_name = f"tile_{level}_{col}_{row}.{pyramid.tile_extension}"
+                        with open(tile_name, "wb") as image:
+                            image.write(data)
+                        print (f"Tile written in {tile_name}")
+
+                except Exception as e:
+                    print("Cannot save a pyramid's tile : {e}")
+
+        Raises:
+            Exception: Level not found in the pyramid
+            NotImplementedError: Pyramid owns one-tile slabs
+            MissingEnvironmentError: Missing object storage informations
+            StorageError: Storage read issue
+
+        Returns:
+            str: data, as binary string, None if no data
+        """
+
+        level_object = self.get_level(level)
+
+        if level_object is None:
+            raise Exception(f"No level {level} in the pyramid")
+
+        if level_object.slab_width == 1 and level_object.slab_height == 1:
+            raise NotImplementedError(f"One-tile slab pyramid is not handled")
+
+        if not level_object.is_in_limits(column, row):
+            return None
+
+        # Indices de la dalle
+        slab_column = column // level_object.slab_width
+        slab_row = row // level_object.slab_height
+
+        # Indices de la tuile dans la dalle
+        relative_tile_column = column % level_object.slab_width
+        relative_tile_row = row % level_object.slab_height
+
+        # Numéro de la tuile dans le header
+        tile_index = relative_tile_row * level_object.slab_width + relative_tile_column
+
+        # Calcul du chemin de la dalle contenant la tuile voulue
+        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,
+        # puis sont stockés les offsets (chacun sur 4 octets)
+        # puis les tailles (chacune sur 4 octets)
+        try:
+            binary_index = get_data_binary(
+                slab_path,
+                (
+                    ROK4_IMAGE_HEADER_SIZE,
+                    2 * 4 * level_object.slab_width * level_object.slab_height,
+                ),
+            )
+        except FileNotFoundError as e:
+            # L'absence de la dalle est gérée comme simplement une absence de données
+            return None
+
+        offsets = numpy.frombuffer(
+            binary_index,
+            dtype=numpy.dtype("uint32"),
+            count=level_object.slab_width * level_object.slab_height,
+        )
+        sizes = numpy.frombuffer(
+            binary_index,
+            dtype=numpy.dtype("uint32"),
+            offset=4 * level_object.slab_width * level_object.slab_height,
+            count=level_object.slab_width * level_object.slab_height,
+        )
+
+        if sizes[tile_index] == 0:
+            return None
+
+        return get_data_binary(slab_path, (offsets[tile_index], sizes[tile_index]))
+
+    def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarray:
+        """Get a raster pyramid's tile as 3-dimension numpy ndarray
+
+        First dimension is the row, second one is column, third one is band.
+
+        Args:
+            level (str): Tile's level
+            column (int): Tile's column
+            row (int): Tile's row
+
+        Limitations:
+            Packbits (pyramid formats TIFF_PKB_FLOAT32 and TIFF_PKB_UINT8) and LZW (pyramid formats TIFF_LZW_FLOAT32 and TIFF_LZW_UINT8) compressions are not handled.
+
+        Raises:
+            Exception: Cannot get raster data for a vector pyramid
+            Exception: Level not found in the pyramid
+            NotImplementedError: Pyramid owns one-tile slabs
+            NotImplementedError: Raster pyramid format not handled
+            MissingEnvironmentError: Missing object storage informations
+            StorageError: Storage read issue
+            FormatError: Cannot decode tile
+
+        Examples:
+
+            FILE stored DTM (raster) pyramid, to get the altitude value at a point in the best level
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("/data/pyramids/RGEALTI.json")
+                    level, col, row, pcol, prow = pyramid.get_tile_indices(44, 5, srs = "EPSG:4326")
+                    data = pyramid.get_tile_data_raster(level, col, row)
+
+                    if data is None:
+                        print("No data")
+                    else:
+                        print(data[prow][pcol])
+
+                except Exception as e:
+                    print("Cannot get a pyramid's pixel value : {e}")
+
+        Returns:
+            str: data, as numpy array, None if no data
+        """
+
+        if self.type == PyramidType.VECTOR:
+            raise Exception("Cannot get tile as raster data : it's a vector pyramid")
+
+        binary_tile = self.get_tile_data_binary(level, column, row)
+
+        if binary_tile is None:
+            return None
+
+        level_object = self.get_level(level)
+
+        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":
+            data = numpy.frombuffer(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"],
+            )
+
+        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":
+            try:
+                data = numpy.frombuffer(zlib.decompress(binary_tile), dtype=numpy.dtype("uint8"))
+            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"],
+            )
+
+        elif self.__format == "TIFF_ZIP_FLOAT32":
+            try:
+                data = numpy.frombuffer(zlib.decompress(binary_tile), dtype=numpy.dtype("float32"))
+            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"],
+            )
+
+        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"],
+            )
+
+        else:
+            raise NotImplementedError(f"Cannot get tile as raster data for format {self.__format}")
+
+        return data
+
+    def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
+        """Get a vector pyramid's tile as GeoJSON dictionnary
+
+        Args:
+            level (str): Tile's level
+            column (int): Tile's column
+            row (int): Tile's row
+
+        Raises:
+            Exception: Cannot get vector data for a raster pyramid
+            Exception: Level not found in the pyramid
+            NotImplementedError: Pyramid owns one-tile slabs
+            NotImplementedError: Vector pyramid format not handled
+            MissingEnvironmentError: Missing object storage informations
+            StorageError: Storage read issue
+            FormatError: Cannot decode tile
+
+        Examples:
+
+            S3 stored vector pyramid, to print a tile as GeoJSON
+
+                from rok4.pyramid import Pyramid
+                import json
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://pyramids/vectors/BDTOPO.json")
+                    level, col, row, pcol, prow = pyramid.get_tile_indices(40.325, 3.123, srs = "EPSG:4326")
+                    data = pyramid.get_tile_data_vector(level, col, row)
+
+                    if data is None:
+                        print("No data")
+                    else:
+                        print(json.dumps(data))
+
+                except Exception as e:
+                    print("Cannot print a vector pyramid's tile as GeoJSON : {e}")
+
+        Returns:
+            str: data, as GeoJSON dictionnary. None if no data
+        """
+
+        if self.type == PyramidType.RASTER:
+            raise Exception("Cannot get tile as vector data : it's a raster pyramid")
+
+        binary_tile = self.get_tile_data_binary(level, column, row)
+
+        if binary_tile is None:
+            return None
+
+        level_object = self.get_level(level)
+
+        if self.__format == "TIFF_PBF_MVT":
+            try:
+                data = mapbox_vector_tile.decode(binary_tile)
+            except Exception as e:
+                raise FormatError("PBF (MVT)", "binary tile", e)
+        else:
+            raise NotImplementedError(f"Cannot get tile as vector data for format {self.__format}")
+
+        return data
+
+    def get_tile_indices(
+        self, x: float, y: float, level: str = None, **kwargs
+    ) -> Tuple[str, int, int, int, int]:
+        """Get pyramid's tile and pixel indices from point's coordinates
+
+        Used coordinates system have to be the pyramid one. If EPSG:4326, x is latitude and y longitude.
+
+        Args:
+            x (float): point's x
+            y (float): point's y
+            level (str, optional): Pyramid's level to take into account, the bottom one if None . Defaults to None.
+            **srs (string): spatial reference system of provided coordinates, with authority and code (same as the pyramid's one if not provided)
+
+        Raises:
+            Exception: Cannot find level to calculate indices
+            RuntimeError: Provided SRS is invalid for OSR
+
+        Examples:
+
+            FILE stored DTM (raster) pyramid, to get the altitude value at a point in the best level
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("/data/pyramids/RGEALTI.json")
+                    level, col, row, pcol, prow = pyramid.get_tile_indices(44, 5, srs = "EPSG:4326")
+                    data = pyramid.get_tile_data_raster(level, col, row)
+
+                    if data is None:
+                        print("No data")
+                    else:
+                        print(data[prow][pcol])
+
+                except Exception as e:
+                    print("Cannot get a pyramid's pixel value : {e}")
+
+        Returns:
+            Tuple[str, int, int, int, int]: Level identifier, tile's column, tile's row, pixel's (in the tile) column, pixel's row
+        """
+
+        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")
+
+        if (
+            "srs" in kwargs
+            and kwargs["srs"] is not None
+            and kwargs["srs"].upper() != self.__tms.srs.upper()
+        ):
+            sr = srs_to_spatialreference(kwargs["srs"])
+            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
+
+        Examples:
+
+                from rok4.pyramid import Pyramid
+
+                try:
+                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
+                    size = 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/Raster.py b/src/rok4/raster.py
similarity index 97%
rename from src/rok4/Raster.py
rename to src/rok4/raster.py
index 271fc6a..1c1ac36 100644
--- a/src/rok4/Raster.py
+++ b/src/rok4/raster.py
@@ -14,8 +14,9 @@
 
 from osgeo import gdal, ogr
 
-from rok4.Storage import exists, get_osgeo_path, put_data_str
-from rok4.Utils import ColorFormat, compute_bbox, compute_format
+from rok4.storage import exists, get_osgeo_path, put_data_str
+from rok4.utils import compute_bbox, compute_format
+from rok4.enums import ColorFormat
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
@@ -59,7 +60,7 @@ def from_file(cls, path: str) -> "Raster":
 
             Loading informations from a file stored raster TIFF image
 
-                from rok4.Raster import Raster
+                from rok4.raster import Raster
 
                 try:
                     raster = Raster.from_file(
@@ -141,7 +142,7 @@ def from_parameters(
             Loading informations from parameters, related to
               a TIFF main image coupled to a TIFF mask image
 
-                from rok4.Raster import Raster
+                from rok4.raster import Raster
 
                 try:
                     raster = Raster.from_parameters(
@@ -213,7 +214,7 @@ def from_list(cls, path: str, srs: str) -> "RasterSet":
 
             Loading informations from a file stored list
 
-                from rok4.Raster import RasterSet
+                from rok4.raster import RasterSet
 
                 try:
                     raster_set = RasterSet.from_list(
@@ -276,7 +277,7 @@ def from_descriptor(cls, path: str) -> "RasterSet":
 
             Loading informations from a file stored descriptor
 
-                from rok4.Raster import RasterSet
+                from rok4.raster import RasterSet
 
                 try:
                     raster_set = RasterSet.from_descriptor(
diff --git a/src/rok4/Storage.py b/src/rok4/storage.py
similarity index 94%
rename from src/rok4/Storage.py
rename to src/rok4/storage.py
index efc3696..54e2837 100644
--- a/src/rok4/Storage.py
+++ b/src/rok4/storage.py
@@ -30,24 +30,23 @@
 To precise the cluster to use, bucket name should be bucket_name@s3.storage.fr or bucket_name@s4.storage.fr. If no host is defined (no @) in the bucket name, first S3 cluster is used
 """
 
-import hashlib
-import os
-import re
-import tempfile
-from enum import Enum
-from shutil import copyfile
-from typing import Dict, List, Tuple, Union
-
 import boto3
 import botocore.exceptions
+import tempfile
+import re
+import os
 import rados
+import hashlib
 import requests
+from typing import Dict, List, Tuple, Union
+from enum import Enum
+from shutil import copyfile
 from osgeo import gdal
 
 gdal.UseExceptions()
 
+from rok4.exceptions import *
 from rok4.enums import StorageType
-from rok4.Exceptions import *
 
 
 __S3_CLIENTS = {}
@@ -69,7 +68,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
     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:
@@ -128,7 +127,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
 
 def disconnect_s3_clients() -> None:
     """Clean S3 clients"""
-
+  
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
     __S3_CLIENTS = {}
     __S3_DEFAULT_CLIENT = None
@@ -357,15 +356,16 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-        if range is None:
+
+        if range is None :
             try:
                 reponse = requests.get(f"{storage_type.value}{path}", stream=True)
                 data = reponse.content
-                if reponse.status_code == 404:
+                if reponse.status_code == 404 :
                     raise FileNotFoundError(f"{storage_type.value}{path}")
             except Exception as e:
                 raise StorageError(storage_type.name, e)
-        else:
+        else :
             raise NotImplementedError
 
     else:
@@ -464,6 +464,7 @@ def get_size(path: str) -> int:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
+
         try:
             # Le stream=True permet de ne télécharger que le header initialement
             reponse = requests.get(storage_type.value + path, stream=True).headers["content-length"]
@@ -518,11 +519,12 @@ def exists(path: str) -> bool:
         return os.path.exists(path)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
+
         try:
             response = requests.get(storage_type.value + path, stream=True)
-            if response.status_code == 200:
+            if response.status_code == 200 :
                 return True
-            else:
+            else :
                 return False
         except Exception as e:
             raise StorageError(storage_type.name, e)
@@ -830,52 +832,43 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}"
             )
 
-    elif (
-        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
-    ) and to_type == StorageType.FILE:
+    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.FILE :
+
         try:
-            response = requests.get(from_type.value + from_path, stream=True)
+            response = requests.get(from_type.value + from_path, stream = True)
             with open(to_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=65536):
+                for chunk in response.iter_content(chunk_size=65536) :
                     if chunk:
                         f.write(chunk)
 
         except Exception as e:
-            raise StorageError(
-                f"HTTP(S) and FILE",
-                f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}",
-            )
+            raise StorageError(f"HTTP(S) and FILE", f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}")
+
+    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.CEPH :
 
-    elif (
-        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
-    ) and to_type == StorageType.CEPH:
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream=True)
+            response = requests.get(from_type.value + from_path, stream = True)
             offset = 0
-            for chunk in response.iter_content(chunk_size=65536):
+            for chunk in response.iter_content(chunk_size=65536) :
                 if chunk:
                     size = len(chunk)
                     to_ioctx.write(to_base_name, chunk, offset)
                     offset += size
 
         except Exception as e:
-            raise StorageError(
-                f"HTTP(S) and CEPH",
-                f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}",
-            )
+            raise StorageError(f"HTTP(S) and CEPH", f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}")
+
+    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.S3 :
 
-    elif (
-        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
-    ) and to_type == StorageType.S3:
         to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream=True)
-            with tempfile.NamedTemporaryFile("w+b", delete=False) as f:
+            response = requests.get(from_type.value + from_path, stream = True)
+            with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
                 name_fich = f.name
-                for chunk in response.iter_content(chunk_size=65536):
+                for chunk in response.iter_content(chunk_size=65536) :
                     if chunk:
                         f.write(chunk)
 
@@ -884,10 +877,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             os.remove(name_fich)
 
         except Exception as e:
-            raise StorageError(
-                f"HTTP(S) and S3",
-                f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}",
-            )
+            raise StorageError(f"HTTP(S) and S3", f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}")
 
     else:
         raise StorageError(
@@ -934,9 +924,11 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
 
         try:
             target_s3_client["client"].put_object(
-                Body = f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode(),
-                Bucket = link_bucket,
-                Key = link_base_name
+                Body=f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode(
+                    "utf-8"
+                ),
+                Bucket=link_bucket,
+                Key=link_base_name,
             )
         except Exception as e:
             raise StorageError("S3", e)
@@ -945,7 +937,9 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
         ioctx = __get_ceph_ioctx(link_tray)
 
         try:
-            ioctx.write_full(link_base_name, f"{__OBJECT_SYMLINK_SIGNATURE}{target_path}".encode())
+            ioctx.write_full(
+                link_base_name, f"{__OBJECT_SYMLINK_SIGNATURE}{target_path}".encode("utf-8")
+            )
         except Exception as e:
             raise StorageError("CEPH", e)
 
@@ -997,8 +991,7 @@ 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:
+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:
@@ -1011,10 +1004,10 @@ def size_path(path: str) -> int:
     Returns:
         int: size of the path
     """
-    storage_type, unprefixed_path, tray_name, base_name = get_infos_from_path(path)
+    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
 
     if storage_type == StorageType.FILE:
-        try:
+        try :
             total = 0
             with os.scandir(unprefixed_path) as it:
                 for entry in it:
@@ -1029,23 +1022,24 @@ def size_path(path: str) -> int:
     elif storage_type == StorageType.S3:
         s3_client, bucket_name = __get_s3_client(tray_name)
 
-        try:
-            paginator = s3_client["client"].get_paginator("list_objects_v2")
+        try :
+            paginator = s3_client["client"].get_paginator('list_objects_v2')
             pages = paginator.paginate(
                 Bucket=bucket_name,
-                Prefix=base_name + "/",
+                Prefix=base_name+"/",
                 PaginationConfig={
-                    "PageSize": 10000,
-                },
+                    'PageSize': 10000,
+                }
             )
             total = 0
             for page in pages:
-                for key in page["Contents"]:
-                    total += key["Size"]
+                for key in page['Contents']:
+                    total += key['Size']
 
         except Exception as e:
             raise StorageError("S3", e)
 
+
     elif storage_type == StorageType.CEPH:
         raise NotImplementedError
     else:
diff --git a/src/rok4/TileMatrixSet.py b/src/rok4/tile_matrix_set.py
similarity index 98%
rename from src/rok4/TileMatrixSet.py
rename to src/rok4/tile_matrix_set.py
index 3000492..06d4466 100644
--- a/src/rok4/TileMatrixSet.py
+++ b/src/rok4/tile_matrix_set.py
@@ -9,14 +9,14 @@
 - ROK4_TMS_DIRECTORY
 """
 
+from typing import Dict, List, Tuple
+from json.decoder import JSONDecodeError
 import json
 import os
-from json.decoder import JSONDecodeError
-from typing import Dict, List, Tuple
 
-from rok4.Exceptions import *
-from rok4.Storage import get_data_str
-from rok4.Utils import *
+from rok4.exceptions import *
+from rok4.storage import get_data_str
+from rok4.utils import *
 
 
 class TileMatrix:
diff --git a/src/rok4/Utils.py b/src/rok4/utils.py
similarity index 99%
rename from src/rok4/Utils.py
rename to src/rok4/utils.py
index 53450d7..d7d3ef7 100644
--- a/src/rok4/Utils.py
+++ b/src/rok4/utils.py
@@ -13,6 +13,7 @@
 osr.UseExceptions()
 gdal.UseExceptions()
 
+from rok4.enums import ColorFormat
 
 __SR_BOOK = {}
 
diff --git a/src/rok4/Vector.py b/src/rok4/vector.py
similarity index 98%
rename from src/rok4/Vector.py
rename to src/rok4/vector.py
index 46656c2..5478056 100644
--- a/src/rok4/Vector.py
+++ b/src/rok4/vector.py
@@ -6,17 +6,16 @@
 
 """
 
+from osgeo import ogr
 import os
 import tempfile
 
-from osgeo import ogr
-
-from rok4.Exceptions import *
-from rok4.Storage import copy, get_osgeo_path
-
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
+from rok4.storage import get_osgeo_path, copy
+from rok4.exceptions import *
+
 
 class Vector:
     """A data vector
@@ -41,7 +40,7 @@ def from_file(cls, path: str, **kwargs) -> "Vector":
 
         Examples:
 
-            from rok4.Vector import Vector
+            from rok4.vector import Vector
 
             try:
                 vector = Vector.from_file("file://tests/fixtures/ARRONDISSEMENT.shp")
diff --git a/tests/test_Layer.py b/tests/test_layer.py
similarity index 91%
rename from tests/test_Layer.py
rename to tests/test_layer.py
index bbf71eb..8d515da 100644
--- a/tests/test_Layer.py
+++ b/tests/test_layer.py
@@ -1,21 +1,21 @@
+import pytest
 import os
-from unittest import mock
-from unittest.mock import *
 
-import pytest
+from unittest.mock import *
+from unittest import mock
 
-from rok4.Exceptions import *
-from rok4.Layer import Layer
+from rok4.layer import Layer
 from rok4.enums import PyramidType
+from rok4.exceptions import *
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch(
-    "rok4.Layer.get_data_str",
+    "rok4.layer.get_data_str",
     return_value='{"pyramids" : [{"bottom_level" : "10","top_level" : "10","path" : "s3://pyramids/SCAN1000.json"}],"title" : "SCAN1000","bbox":{"east": 11.250000000000997,"west": -5.624999999999043,"north": 52.48278022207774,"south": 40.9798980696195},"styles" : ["normal","hypso"],"abstract" : "Diffusion de la donnée BDORTHO","resampling" : "linear","keywords" : ["PM","TIFF_JPG_UINT8"]}',
 )
-@mock.patch("rok4.Layer.Pyramid.from_descriptor")
-@mock.patch("rok4.Layer.put_data_str", return_value=None)
+@mock.patch("rok4.layer.Pyramid.from_descriptor")
+@mock.patch("rok4.layer.put_data_str", return_value=None)
 def test_descriptor_ok(mocked_put_data_str, mocked_pyramid_class, mocked_get_data_str):
     tms_instance = MagicMock()
     tms_instance.srs = "EPSG:3857"
@@ -51,9 +51,9 @@ def test_descriptor_ok(mocked_put_data_str, mocked_pyramid_class, mocked_get_dat
         assert False, f"Layer creation from descriptor raises an exception: {exc}"
 
 
-@mock.patch("rok4.Layer.Pyramid.from_descriptor")
-@mock.patch("rok4.Layer.reproject_bbox", return_value=(0, 0, 100, 100))
-@mock.patch("rok4.Layer.put_data_str", return_value=None)
+@mock.patch("rok4.layer.Pyramid.from_descriptor")
+@mock.patch("rok4.layer.reproject_bbox", return_value=(0, 0, 100, 100))
+@mock.patch("rok4.layer.put_data_str", return_value=None)
 def test_parameters_vector_ok(
     mocked_put_data_str, mocked_utils_reproject_bbox, mocked_pyramid_class
 ):
@@ -97,9 +97,9 @@ def test_parameters_vector_ok(
         assert False, f"Layer creation from parameters raises an exception: {exc}"
 
 
-@mock.patch("rok4.Layer.Pyramid.from_descriptor")
-@mock.patch("rok4.Layer.reproject_bbox", return_value=(0, 0, 100, 100))
-@mock.patch("rok4.Layer.put_data_str", return_value=None)
+@mock.patch("rok4.layer.Pyramid.from_descriptor")
+@mock.patch("rok4.layer.reproject_bbox", return_value=(0, 0, 100, 100))
+@mock.patch("rok4.layer.put_data_str", return_value=None)
 def test_parameters_raster_ok(
     mocked_put_data_str, mocked_utils_reproject_bbox, mocked_pyramid_class
 ):
diff --git a/tests/test_Pyramid.py b/tests/test_pyramid.py
similarity index 92%
rename from tests/test_Pyramid.py
rename to tests/test_pyramid.py
index 3b75be5..fa04a01 100644
--- a/tests/test_Pyramid.py
+++ b/tests/test_pyramid.py
@@ -1,25 +1,22 @@
+import pytest
 import os
-from unittest import mock
 from unittest.mock import *
+from unittest import mock
 
-import pytest
-
-from rok4.Exceptions import *
-from rok4.Pyramid import *
-from rok4.TileMatrixSet import TileMatrixSet
+from rok4.pyramid import *
+from rok4.tile_matrix_set import TileMatrixSet
 from rok4.enums import SlabType, StorageType
+from rok4.utils import *
+from rok4.exceptions import *
 
-from rok4.Utils import *
-
-
-@mock.patch("rok4.Pyramid.get_data_str", side_effect=StorageError("FILE", "Not found"))
+@mock.patch("rok4.pyramid.get_data_str", side_effect=StorageError("FILE", "Not found"))
 def test_wrong_file(mocked_get_data_str):
     with pytest.raises(StorageError):
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
 
 
 @mock.patch(
-    "rok4.Pyramid.get_data_str",
+    "rok4.pyramid.get_data_str",
     return_value='{"format": "TIFF_PBF_MVT","levels":[{"id": "100","tables":',
 )
 def test_bad_json(mocked_get_data_str):
@@ -33,7 +30,7 @@ def test_bad_json(mocked_get_data_str):
     mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
 
 
-@mock.patch("rok4.Pyramid.get_data_str", return_value='{"format": "TIFF_PBF_MVT","levels":[]}')
+@mock.patch("rok4.pyramid.get_data_str", return_value='{"format": "TIFF_PBF_MVT","levels":[]}')
 def test_missing_tms(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
@@ -44,10 +41,10 @@ def test_missing_tms(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch(
-    "rok4.Pyramid.get_data_str",
+    "rok4.pyramid.get_data_str",
     return_value='{"format": "TIFF_PBF_MVT","levels":[{}], "tile_matrix_set": "PM"}',
 )
-@mock.patch("rok4.Pyramid.TileMatrixSet", side_effect=StorageError("FILE", "TMS not found"))
+@mock.patch("rok4.pyramid.TileMatrixSet", side_effect=StorageError("FILE", "TMS not found"))
 def test_wrong_tms(mocked_tms_constructor, mocked_get_data_str):
     with pytest.raises(StorageError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
@@ -59,10 +56,10 @@ def test_wrong_tms(mocked_tms_constructor, mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch(
-    "rok4.Pyramid.get_data_str",
+    "rok4.pyramid.get_data_str",
     return_value='{"format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}',
 )
-@mock.patch("rok4.Pyramid.TileMatrixSet")
+@mock.patch("rok4.pyramid.TileMatrixSet")
 def test_raster_missing_raster_specifications(mocked_tms_class, mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
@@ -73,10 +70,10 @@ def test_raster_missing_raster_specifications(mocked_tms_class, mocked_get_data_
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch(
-    "rok4.Pyramid.get_data_str",
+    "rok4.pyramid.get_data_str",
     return_value='{"raster_specifications":{"channels":3,"nodata":"255,0,0","photometric":"rgb","interpolation":"bicubic"}, "format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"unknown"}], "tile_matrix_set": "PM"}',
 )
-@mock.patch("rok4.Pyramid.TileMatrixSet")
+@mock.patch("rok4.pyramid.TileMatrixSet")
 def test_wrong_level(mocked_tms_class, mocked_get_data_str):
     tms_instance = MagicMock()
     tms_instance.get_level.return_value = None
@@ -97,10 +94,10 @@ def test_wrong_level(mocked_tms_class, mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch(
-    "rok4.Pyramid.get_data_str",
+    "rok4.pyramid.get_data_str",
     return_value='{"format": "TIFF_PBF_MVT","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}',
 )
-@mock.patch("rok4.Pyramid.TileMatrixSet", autospec=True)
+@mock.patch("rok4.pyramid.TileMatrixSet", autospec=True)
 def test_vector_missing_tables(mocked_tms_class, mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
@@ -111,11 +108,11 @@ def test_vector_missing_tables(mocked_tms_class, mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch(
-    "rok4.Pyramid.get_data_str",
+    "rok4.pyramid.get_data_str",
     return_value='{"raster_specifications":{"channels":3,"nodata":"255,0,0","photometric":"rgb","interpolation":"bicubic"}, "format": "TIFF_JPG_UINT8","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_prefix":"SCAN1000/DATA_0","pool_name":"pool1","type":"CEPH"},"tiles_per_width":16,"id":"0"}], "tile_matrix_set": "PM"}',
 )
-@mock.patch("rok4.Pyramid.TileMatrixSet")
-@mock.patch("rok4.Pyramid.put_data_str", return_value=None)
+@mock.patch("rok4.pyramid.TileMatrixSet")
+@mock.patch("rok4.pyramid.put_data_str", return_value=None)
 def test_raster_ok(mocked_put_data_str, mocked_tms_class, mocked_get_data_str):
     tms_instance = MagicMock()
     tms_instance.name = "PM"
@@ -169,10 +166,10 @@ def test_raster_ok(mocked_put_data_str, mocked_tms_class, mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch(
-    "rok4.Pyramid.get_data_str",
+    "rok4.pyramid.get_data_str",
     return_value='{"format": "TIFF_PBF_MVT","levels":[{"tiles_per_height":16,"tile_limits":{"min_col":0,"max_row":15,"max_col":15,"min_row":0},"storage":{"image_directory":"SCAN1000/DATA/0","path_depth":2,"type":"FILE"},"tiles_per_width":16,"id":"0","tables":[{"name":"table","geometry":"POINT","attributes":[{"type":"bigint","name":"fid","count":1531}]}]}], "tile_matrix_set": "PM"}',
 )
-@mock.patch("rok4.Pyramid.TileMatrixSet")
+@mock.patch("rok4.pyramid.TileMatrixSet")
 def test_vector_ok(mocked_tms_class, mocked_get_data_str):
     try:
         pyramid = Pyramid.from_descriptor("file:///pyramid.json")
@@ -197,7 +194,7 @@ def test_vector_ok(mocked_tms_class, mocked_get_data_str):
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("rok4.Pyramid.TileMatrixSet")
+@mock.patch("rok4.pyramid.TileMatrixSet")
 def test_tile_read_raster(mocked_tms_class):
     tms_instance = MagicMock()
     tms_instance.name = "UTM20W84MART_1M_MNT"
@@ -222,7 +219,7 @@ def test_tile_read_raster(mocked_tms_class):
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("rok4.Pyramid.TileMatrixSet")
+@mock.patch("rok4.pyramid.TileMatrixSet")
 def test_tile_read_vector(mocked_tms_class):
     tms_instance = MagicMock()
     tms_instance.name = "PM"
@@ -250,7 +247,7 @@ def test_tile_read_vector(mocked_tms_class):
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("rok4.Pyramid.TileMatrixSet")
+@mock.patch("rok4.pyramid.TileMatrixSet")
 def test_list_read(mocked_tms_class):
     tms_instance = MagicMock()
     tms_instance.name = "PM"
diff --git a/tests/test_Raster.py b/tests/test_raster.py
similarity index 91%
rename from tests/test_Raster.py
rename to tests/test_raster.py
index cc79846..c91f527 100644
--- a/tests/test_Raster.py
+++ b/tests/test_raster.py
@@ -1,4 +1,4 @@
-"""Describes unit tests for the rok4.Raster module.
+"""Describes unit tests for the rok4.raster module.
 
 There is one test class for each tested functionnality.
 See internal docstrings for more information.
@@ -14,14 +14,14 @@
 
 import pytest
 
-from rok4.Raster import Raster, RasterSet
-from rok4.Utils import ColorFormat
+from rok4.raster import Raster, RasterSet
+from rok4.enums import ColorFormat
 
-# rok4.Raster.Raster class tests
+# rok4.raster.Raster class tests
 
 
 class TestRasterInit(TestCase):
-    """rok4.Raster.Raster default constructor."""
+    """rok4.raster.Raster default constructor."""
 
     def test_default(self):
         """Default property values."""
@@ -44,7 +44,7 @@ def test_default(self):
 
 
 class TestRasterFromFile(TestCase):
-    """rok4.Raster.Raster.from_file(path) class constructor."""
+    """rok4.raster.Raster.from_file(path) class constructor."""
 
     def setUp(self):
         self.source_image_path = "file:///home/user/image.tif"
@@ -60,18 +60,18 @@ def test_empty(self):
         with pytest.raises(TypeError):
             Raster.from_file()
 
-    @mock.patch("rok4.Raster.exists", return_value=False)
+    @mock.patch("rok4.raster.exists", return_value=False)
     def test_image_not_found(self, m_exists):
         """Constructor called on a path matching no file or object."""
         with pytest.raises(Exception):
             Raster.from_file(self.source_image_path)
         m_exists.assert_called_once_with(self.source_image_path)
 
-    @mock.patch("rok4.Raster.get_osgeo_path")
-    @mock.patch("rok4.Raster.compute_format", return_value=ColorFormat.UINT8)
-    @mock.patch("rok4.Raster.gdal.Open")
-    @mock.patch("rok4.Raster.compute_bbox")
-    @mock.patch("rok4.Raster.exists", side_effect=[True, False])
+    @mock.patch("rok4.raster.get_osgeo_path")
+    @mock.patch("rok4.raster.compute_format", return_value=ColorFormat.UINT8)
+    @mock.patch("rok4.raster.gdal.Open")
+    @mock.patch("rok4.raster.compute_bbox")
+    @mock.patch("rok4.raster.exists", side_effect=[True, False])
     def test_image(self, m_exists, m_compute_bbox, m_gdal_open, m_compute_format, m_get_osgeo_path):
         """Constructor called nominally on an image without mask."""
         m_compute_bbox.return_value = self.bbox
@@ -104,12 +104,12 @@ def test_image(self, m_exists, m_compute_bbox, m_gdal_open, m_compute_format, m_
         assert raster.format == ColorFormat.UINT8
         assert raster.dimensions == self.image_size
 
-    @mock.patch("rok4.Raster.get_osgeo_path")
-    @mock.patch("rok4.Raster.compute_format", return_value=ColorFormat.UINT8)
-    @mock.patch("rok4.Raster.gdal.IdentifyDriver")
-    @mock.patch("rok4.Raster.gdal.Open")
-    @mock.patch("rok4.Raster.compute_bbox")
-    @mock.patch("rok4.Raster.exists", side_effect=[True, True])
+    @mock.patch("rok4.raster.get_osgeo_path")
+    @mock.patch("rok4.raster.compute_format", return_value=ColorFormat.UINT8)
+    @mock.patch("rok4.raster.gdal.IdentifyDriver")
+    @mock.patch("rok4.raster.gdal.Open")
+    @mock.patch("rok4.raster.compute_bbox")
+    @mock.patch("rok4.raster.exists", side_effect=[True, True])
     def test_image_and_mask(
         self,
         m_exists,
@@ -154,9 +154,9 @@ def test_image_and_mask(
         assert raster.format == ColorFormat.UINT8
         assert raster.dimensions == self.image_size
 
-    @mock.patch("rok4.Raster.get_osgeo_path")
-    @mock.patch("rok4.Raster.gdal.Open", side_effect=RuntimeError)
-    @mock.patch("rok4.Raster.exists", side_effect=[True, False])
+    @mock.patch("rok4.raster.get_osgeo_path")
+    @mock.patch("rok4.raster.gdal.Open", side_effect=RuntimeError)
+    @mock.patch("rok4.raster.exists", side_effect=[True, False])
     def test_unsupported_image_format(self, m_exists, m_gdal_open, m_get_osgeo_path):
         """Test case : Constructor called on an unsupported image file or object."""
         m_get_osgeo_path.return_value = self.osgeo_image_path
@@ -168,10 +168,10 @@ def test_unsupported_image_format(self, m_exists, m_gdal_open, m_get_osgeo_path)
         m_get_osgeo_path.assert_called_once_with(self.source_image_path)
         m_gdal_open.assert_called_once_with(self.osgeo_image_path)
 
-    @mock.patch("rok4.Raster.get_osgeo_path")
-    @mock.patch("rok4.Raster.gdal.IdentifyDriver")
-    @mock.patch("rok4.Raster.gdal.Open", side_effect=None)
-    @mock.patch("rok4.Raster.exists", side_effect=[True, True])
+    @mock.patch("rok4.raster.get_osgeo_path")
+    @mock.patch("rok4.raster.gdal.IdentifyDriver")
+    @mock.patch("rok4.raster.gdal.Open", side_effect=None)
+    @mock.patch("rok4.raster.exists", side_effect=[True, True])
     def test_unsupported_mask_format(
         self, m_exists, m_gdal_open, m_identifydriver, m_get_osgeo_path
     ):
@@ -191,7 +191,7 @@ def test_unsupported_mask_format(
 
 
 class TestRasterFromParameters(TestCase):
-    """rok4.Raster.Raster.from_parameters(**kwargs) class constructor."""
+    """rok4.raster.Raster.from_parameters(**kwargs) class constructor."""
 
     def test_image(self):
         """Parameters describing an image without mask"""
@@ -247,11 +247,11 @@ def test_image_and_mask(self):
         assert raster.mask == parameters["mask"]
 
 
-# rok4.Raster.RasterSet class tests
+# rok4.raster.RasterSet class tests
 
 
 class TestRasterSetInit(TestCase):
-    """rok4.Raster.RasterSet default constructor."""
+    """rok4.raster.RasterSet default constructor."""
 
     def test_default(self):
         """Default property values."""
@@ -268,10 +268,10 @@ def test_default(self):
 
 
 class TestRasterSetFromList(TestCase):
-    """rok4.Raster.RasterSet.from_list(path, srs) class constructor."""
+    """rok4.raster.RasterSet.from_list(path, srs) class constructor."""
 
-    @mock.patch("rok4.Raster.get_osgeo_path")
-    @mock.patch("rok4.Raster.Raster.from_file")
+    @mock.patch("rok4.raster.get_osgeo_path")
+    @mock.patch("rok4.raster.Raster.from_file")
     def test_ok_at_least_3_files(self, m_from_file, m_get_osgeo_path):
         """List of 3 or more valid image files"""
         file_number = random.randint(3, 100)
@@ -326,7 +326,7 @@ def test_ok_at_least_3_files(self, m_from_file, m_get_osgeo_path):
         bbox = (-0.75, -1.33, 0.25 + math.floor((file_number - 1) / 3), 1.67)
         serial_in["bbox"] = list(bbox)
 
-        with mock.patch("rok4.Raster.open", m_open):
+        with mock.patch("rok4.raster.open", m_open):
             rasterset = RasterSet.from_list(list_path, srs)
 
         serial_out = rasterset.serializable
@@ -347,10 +347,10 @@ def test_ok_at_least_3_files(self, m_from_file, m_get_osgeo_path):
 
 
 class TestRasterSetFromDescriptor(TestCase):
-    """rok4.Raster.RasterSet.from_descriptor(path) class constructor."""
+    """rok4.raster.RasterSet.from_descriptor(path) class constructor."""
 
-    @mock.patch("rok4.Raster.get_osgeo_path")
-    @mock.patch("rok4.Raster.Raster.from_parameters")
+    @mock.patch("rok4.raster.get_osgeo_path")
+    @mock.patch("rok4.raster.Raster.from_parameters")
     def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
         serial_in = {
             "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
@@ -401,7 +401,7 @@ def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
         m_get_osgeo_path.return_value = local_path
         m_open = mock_open(read_data=desc_content)
 
-        with mock.patch("rok4.Raster.open", m_open):
+        with mock.patch("rok4.raster.open", m_open):
             rasterset = RasterSet.from_descriptor(desc_path)
 
         m_get_osgeo_path.assert_called_once_with(desc_path)
@@ -429,9 +429,9 @@ def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
 
 
 class TestRasterSetWriteDescriptor(TestCase):
-    """rok4.Raster.RasterSet.write_descriptor(path) class method."""
+    """rok4.raster.RasterSet.write_descriptor(path) class method."""
 
-    @mock.patch("rok4.Raster.put_data_str")
+    @mock.patch("rok4.raster.put_data_str")
     def test_ok_with_output_path(self, m_put_data_str):
         serial_in = {
             "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
@@ -489,7 +489,7 @@ def test_ok_with_output_path(self, m_put_data_str):
 
         m_put_data_str.assert_called_once_with(content, path)
 
-    @mock.patch("rok4.Raster.print")
+    @mock.patch("rok4.raster.print")
     def test_ok_no_output_path(self, m_print):
         serial_in = {
             "bbox": [550000.000, 6210000.000, 570000.000, 6230000.000],
diff --git a/tests/test_Storage.py b/tests/test_storage.py
similarity index 90%
rename from tests/test_Storage.py
rename to tests/test_storage.py
index 8426ccf..a3f8799 100644
--- a/tests/test_Storage.py
+++ b/tests/test_storage.py
@@ -1,15 +1,15 @@
+import pytest
 import os
-from unittest import mock
-from unittest.mock import *
 
 import botocore.exceptions
-import pytest
 from rados import ObjectNotFound
 
-from rok4.Exceptions import *
-from rok4.Storage import *
-from rok4.enums import StorageType
+from unittest import mock
+from unittest.mock import *
 
+from rok4.storage import *
+from rok4.exceptions import *
+from rok4.enums import StorageType
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @patch("builtins.open", new_callable=mock_open, read_data=b"data")
@@ -21,7 +21,6 @@ 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)
 def test_get_infos_from_path():
     assert (StorageType.S3, "toto/titi", "toto", "titi") == get_infos_from_path("s3://toto/titi")
@@ -77,7 +76,7 @@ def test_s3_invalid_envs():
 @mock.patch.dict(
     os.environ, {"ROK4_S3_URL": "a", "ROK4_S3_SECRETKEY": "b", "ROK4_S3_KEY": "c"}, clear=True
 )
-@mock.patch("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_s3_invalid_endpoint(mocked_s3_client):
     s3_instance = MagicMock()
     mocked_s3_client.side_effect = Exception("Invalid URL")
@@ -104,13 +103,12 @@ 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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_s3_read_nok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -119,13 +117,12 @@ 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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_s3_read_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -146,7 +143,7 @@ def test_s3_read_ok(mocked_s3_client):
     {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"},
     clear=True,
 )
-@mock.patch("rok4.Storage.rados.Rados")
+@mock.patch("rok4.storage.rados.Rados")
 def test_ceph_read_ok(mocked_rados_client):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
@@ -162,9 +159,8 @@ def test_ceph_read_ok(mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH read raises an exception: {exc}"
 
-
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("requests.get", side_effect={"status_code": 404})
+@mock.patch("requests.get", side_effect={"status_code":404})
 def test_http_read_error(mock_http):
     with pytest.raises(StorageError):
         requests_instance = MagicMock()
@@ -175,37 +171,34 @@ def test_http_read_error(mock_http):
 
     mock_http.assert_called_with("http://path/to/file.ext", stream=True)
 
-
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_http_read_range_error():
     with pytest.raises(NotImplementedError):
-        data = get_data_binary("http://path/to/file.ext", (0, 100))
-
+        data = get_data_binary("http://path/to/file.ext", (0,100))
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("requests.get")
 def test_http_read_ok(mock_http):
-    try:
+    try :
         requests_instance = MagicMock()
-        requests_instance.content = b"data"
+        requests_instance.content = b'data'
         mock_http.return_value = requests_instance
 
         data = get_data_str("http://path/to/file.ext")
         mock_http.assert_called_with("http://path/to/file.ext", stream=True)
-        assert data == "data"
+        assert data == 'data'
     except Exception as exc:
         assert False, f"HTTP read raises an exception: {exc}"
 
 
 ############ 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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_s3_write_nok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -221,7 +214,7 @@ def test_s3_write_nok(mocked_s3_client):
     {"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("rok4.storage.boto3.client")
 def test_s3_write_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -232,13 +225,12 @@ def test_s3_write_ok(mocked_s3_client):
     except Exception as exc:
         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("rok4.Storage.rados.Rados")
+@mock.patch("rok4.storage.rados.Rados")
 def test_ceph_write_ok(mocked_rados_client):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
@@ -258,8 +250,8 @@ def test_ceph_write_ok(mocked_rados_client):
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.makedirs", return_value=None)
-@mock.patch("rok4.Storage.copyfile", return_value=None)
-@mock.patch("rok4.Storage.hash_file", return_value="toto")
+@mock.patch("rok4.storage.copyfile", return_value=None)
+@mock.patch("rok4.storage.hash_file", return_value="toto")
 def test_copy_file_file_ok(mock_hash_file, mock_copyfile, mock_makedirs):
     try:
         copy("file:///path/to/source.ext", "file:///path/to/destination.ext", "toto")
@@ -275,9 +267,9 @@ def test_copy_file_file_ok(mock_hash_file, mock_copyfile, mock_makedirs):
     {"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("rok4.storage.boto3.client")
 @mock.patch("os.makedirs", return_value=None)
-@mock.patch("rok4.Storage.hash_file", return_value="toto")
+@mock.patch("rok4.storage.hash_file", return_value="toto")
 def test_copy_s3_file_ok(mock_hash_file, mock_makedirs, mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -297,9 +289,9 @@ def test_copy_s3_file_ok(mock_hash_file, mock_makedirs, mocked_s3_client):
     {"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("rok4.storage.boto3.client")
 @mock.patch("os.makedirs", return_value=None)
-@mock.patch("rok4.Storage.hash_file", return_value="toto")
+@mock.patch("rok4.storage.hash_file", return_value="toto")
 def test_copy_s3_file_nok(mock_hash_file, mock_makedirs, mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -310,13 +302,12 @@ def test_copy_s3_file_nok(mock_hash_file, mock_makedirs, mocked_s3_client):
         copy("s3://bucket/source.ext", "file:///path/to/destination.ext", "toto")
         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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_copy_file_s3_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -329,13 +320,12 @@ def test_copy_file_s3_ok(mocked_s3_client):
     except Exception as exc:
         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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_copy_s3_s3_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -348,13 +338,12 @@ def test_copy_s3_s3_ok(mocked_s3_client):
     except Exception as exc:
         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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_copy_s3_s3_intercluster_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -373,7 +362,7 @@ def test_copy_s3_s3_intercluster_ok(mocked_s3_client):
     {"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("rok4.storage.boto3.client")
 def test_copy_s3_s3_intercluster_nok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -384,13 +373,12 @@ 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("rok4.Storage.rados.Rados")
+@mock.patch("rok4.storage.rados.Rados")
 @mock.patch("os.makedirs", return_value=None)
 @patch("builtins.open", new_callable=mock_open)
 def test_copy_ceph_file_ok(mock_file, mock_makedirs, mocked_rados_client):
@@ -411,13 +399,12 @@ 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("rok4.Storage.rados.Rados")
+@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):
     disconnect_ceph_clients()
@@ -436,13 +423,12 @@ 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("rok4.Storage.rados.Rados")
+@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):
     disconnect_ceph_clients()
@@ -475,8 +461,8 @@ def test_copy_ceph_ceph_ok(mock_file, mocked_rados_client):
     },
     clear=True,
 )
-@mock.patch("rok4.Storage.rados.Rados")
-@mock.patch("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.rados.Rados")
+@mock.patch("rok4.storage.boto3.client")
 @patch("builtins.open", new_callable=mock_open, read_data=b"data")
 def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     disconnect_ceph_clients()
@@ -501,14 +487,14 @@ def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH -> S3 copy raises an exception: {exc}"
 
-
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("requests.get")
-@patch("builtins.open", new_callable=mock_open)
+@mock.patch('requests.get')
+@patch('builtins.open', new_callable=mock_open)
 def test_copy_http_file_ok(mock_open, mock_requests):
     try:
+
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data", "data2"]
+        http_instance.iter_content.return_value = ["data","data2"]
         mock_requests.return_value = http_instance
 
         copy("http://path/to/source.ext", "file:///path/to/destination.ext")
@@ -517,20 +503,17 @@ def test_copy_http_file_ok(mock_open, mock_requests):
     except Exception as exc:
         assert False, f"HTTP -> 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("rok4.Storage.rados.Rados")
-@mock.patch("requests.get")
+@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('requests.get')
 def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     try:
+
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data", "data2"]
+        http_instance.iter_content.return_value = ["data","data2"]
         mock_requests.return_value = http_instance
 
+
         disconnect_ceph_clients()
         ioctx_instance = MagicMock()
         ioctx_instance.write.return_value = None
@@ -543,20 +526,16 @@ def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     except Exception as exc:
         assert False, f"HTTP -> CEPH 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("rok4.Storage.boto3.client")
-@mock.patch("requests.get")
-@patch("tempfile.NamedTemporaryFile", new_callable=mock_open)
-@mock.patch("os.remove")
+@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('requests.get')
+@patch('tempfile.NamedTemporaryFile', new_callable=mock_open)
+@mock.patch('os.remove')
 def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_client):
     try:
+
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data", "data2"]
+        http_instance.iter_content.return_value = ["data","data2"]
         mock_requests.return_value = http_instance
 
         disconnect_s3_clients()
@@ -567,7 +546,7 @@ def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_cl
 
         copy("http://path/to/source.ext", "s3://bucket/destination.ext")
         mock_requests.assert_called_once_with("http://path/to/source.ext", stream=True)
-        mock_tempfile.assert_called_once_with("w+b", delete=False)
+        mock_tempfile.assert_called_once_with("w+b",delete=False)
     except Exception as exc:
         assert False, f"HTTP -> CEPH copy raises an exception: {exc}"
 
@@ -584,7 +563,6 @@ 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("os.symlink", return_value=None)
 def test_link_file_ok(mock_link):
@@ -604,13 +582,12 @@ 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("rok4.Storage.rados.Rados")
+@mock.patch("rok4.storage.rados.Rados")
 def test_link_ceph_ok(mocked_rados_client):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
@@ -630,7 +607,7 @@ def test_link_ceph_ok(mocked_rados_client):
     {"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("rok4.storage.boto3.client")
 def test_link_s3_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -642,13 +619,12 @@ def test_link_s3_ok(mocked_s3_client):
     except Exception as exc:
         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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_link_s3_nok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -661,7 +637,6 @@ def test_link_s3_nok(mocked_s3_client):
 
 ############ get_size
 
-
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.stat")
 def test_size_file_ok(mock_stat):
@@ -672,13 +647,12 @@ 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("rok4.Storage.rados.Rados")
+@mock.patch("rok4.storage.rados.Rados")
 def test_size_ceph_ok(mocked_rados_client):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
@@ -693,13 +667,12 @@ def test_size_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_size_s3_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -712,12 +685,12 @@ def test_size_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"S3 size raises an exception: {exc}"
 
-
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("requests.get")
+@mock.patch('requests.get')
 def test_size_http_ok(mock_requests):
+
     http_instance = MagicMock()
-    http_instance.headers = {"content-length": 12}
+    http_instance.headers = {"content-length":12}
     mock_requests.return_value = http_instance
 
     try:
@@ -744,13 +717,12 @@ 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("rok4.Storage.rados.Rados")
+@mock.patch("rok4.storage.rados.Rados")
 def test_exists_ceph_ok(mocked_rados_client):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
@@ -776,7 +748,7 @@ def test_exists_ceph_ok(mocked_rados_client):
     {"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("rok4.storage.boto3.client")
 def test_exists_s3_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -796,10 +768,10 @@ def test_exists_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"CEPH not exists raises an exception: {exc}"
 
-
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("requests.get")
+@mock.patch('requests.get')
 def test_exists_http_ok(mock_requests):
+
     http_instance = MagicMock()
     http_instance.status_code = 200
     mock_requests.return_value = http_instance
@@ -820,7 +792,6 @@ def test_exists_http_ok(mock_requests):
 
 ############ remove
 
-
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.remove")
 def test_remove_file_ok(mock_remove):
@@ -836,13 +807,12 @@ 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("rok4.Storage.rados.Rados")
+@mock.patch("rok4.storage.rados.Rados")
 def test_remove_ceph_ok(mocked_rados_client):
     disconnect_ceph_clients()
     ioctx_instance = MagicMock()
@@ -862,13 +832,12 @@ def test_remove_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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("rok4.Storage.boto3.client")
+@mock.patch("rok4.storage.boto3.client")
 def test_remove_s3_ok(mocked_s3_client):
     disconnect_s3_clients()
     s3_instance = MagicMock()
@@ -892,7 +861,6 @@ 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"},
@@ -913,7 +881,6 @@ def test_get_osgeo_path_nok():
     with pytest.raises(NotImplementedError):
         get_osgeo_path("ceph://pool/data.ext")
 
-
 ############ size_path
 def test_size_path_file_ok():
     try:
@@ -922,31 +889,22 @@ def test_size_path_file_ok():
     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):
+    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.dict(os.environ, {"ROK4_CEPH_CONFFILE": "a", "ROK4_CEPH_CLUSTERNAME": "b", "ROK4_CEPH_USERNAME": "c"}, clear=True)
 def test_size_path_ceph_nok():
+
     with pytest.raises(NotImplementedError):
         size = size_path("ceph://pool/path")
 
-
-@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.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}]}]
+    pages = [{"Contents" : [{"Size" : 10},{"Size" : 20}]}, {"Contents" : [{"Size" : 50}]}]
     paginator = MagicMock()
     paginator.paginate.return_value = pages
     client = MagicMock()
@@ -958,3 +916,4 @@ def test_size_path_s3_ok(mocked_s3_client):
         assert size == 80
     except Exception as exc:
         assert False, f"S3 size of the path raises an exception: {exc}"
+
diff --git a/tests/test_TileMatrixSet.py b/tests/test_tile_matrix_set.py
similarity index 93%
rename from tests/test_TileMatrixSet.py
rename to tests/test_tile_matrix_set.py
index 5cf6062..b4e58a9 100644
--- a/tests/test_TileMatrixSet.py
+++ b/tests/test_tile_matrix_set.py
@@ -1,12 +1,10 @@
+import pytest
 import os
-from unittest import mock
 from unittest.mock import *
+from unittest import mock
 
-import pytest
-
-from rok4.Exceptions import *
-from rok4.TileMatrixSet import TileMatrixSet
-
+from rok4.tile_matrix_set import TileMatrixSet
+from rok4.exceptions import *
 
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_missing_env():
@@ -15,7 +13,7 @@ def test_missing_env():
 
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
-@mock.patch("rok4.TileMatrixSet.get_data_str", side_effect=StorageError("FILE", "Not found"))
+@mock.patch("rok4.tile_matrix_set.get_data_str", side_effect=StorageError("FILE", "Not found"))
 def test_wrong_file(mocked_get_data_str):
     with pytest.raises(StorageError):
         tms = TileMatrixSet("tms")
@@ -23,7 +21,7 @@ def test_wrong_file(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_bad_json(mocked_get_data_str):
@@ -34,7 +32,7 @@ def test_bad_json(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"]}',
 )
 def test_missing_id(mocked_get_data_str):
@@ -46,7 +44,7 @@ def test_missing_id(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_missing_crs(mocked_get_data_str):
@@ -58,7 +56,7 @@ def test_missing_crs(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"crs":"epsg:123456","orderedAxes":["X","Y"],"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_wrong_crs(mocked_get_data_str):
@@ -73,7 +71,7 @@ def test_wrong_crs(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"crs":"epsg:4326","orderedAxes":["Lat","Lon"],"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"id":"PM"}',
 )
 def test_wrong_axes_order(mocked_get_data_str):
@@ -88,7 +86,7 @@ def test_wrong_axes_order(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_missing_levels(mocked_get_data_str):
@@ -100,7 +98,7 @@ def test_missing_levels(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"tileMatrices":[],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_no_levels(mocked_get_data_str):
@@ -112,7 +110,7 @@ def test_no_levels(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"tileMatrices":[{"tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"orderedAxes":["X","Y"],"id":"PM","crs":"EPSG:3857"}',
 )
 def test_wrong_level(mocked_get_data_str):
@@ -124,7 +122,7 @@ def test_wrong_level(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"tileMatrices":[{"id":"level_0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_wrong_level_id(mocked_get_data_str):
@@ -140,7 +138,7 @@ def test_wrong_level_id(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"tileMatrices":[{"id":"0","tileWidth":256,"scaleDenominator":559082264.028718,"matrixWidth":1,"cellSize":156543.033928041,"matrixHeight":1,"tileHeight":256,"pointOfOrigin":[-20037508.3427892,20037508.3427892]}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_ok(mocked_get_data_str):
@@ -155,7 +153,7 @@ def test_ok(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"tileMatrices":[{"id":"17","cellSize":1.19432856695588,"matrixHeight":131072,"pointOfOrigin":[-20037508.3427892,20037508.3427892],"tileHeight":256,"tileWidth":256,"scaleDenominator":4265.45916769957,"matrixWidth":131072}],"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_pm_conversions(mocked_get_data_str):
@@ -180,7 +178,7 @@ def test_pm_conversions(mocked_get_data_str):
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch(
-    "rok4.TileMatrixSet.get_data_str",
+    "rok4.tile_matrix_set.get_data_str",
     return_value='{"crs":"EPSG:4326","tileMatrices":[{"tileWidth":256,"scaleDenominator":1066.36480348451,"matrixWidth":524288,"cellSize":2.68220901489258e-06,"matrixHeight":262144,"pointOfOrigin":[-180,90],"tileHeight":256,"id":"18"}],"orderedAxes":["Lon","Lat"],"id":"4326"}',
 )
 def test_4326_conversions(mocked_get_data_str):
diff --git a/tests/test_Utils.py b/tests/test_utils.py
similarity index 90%
rename from tests/test_Utils.py
rename to tests/test_utils.py
index 0f5d67d..37941aa 100644
--- a/tests/test_Utils.py
+++ b/tests/test_utils.py
@@ -1,15 +1,14 @@
-import math
-import os
-import random
-from unittest import mock
-from unittest.mock import *
-
 import pytest
+import os
 from osgeo import gdal, osr
+import math
+import random
 
-from rok4.Exceptions import *
-from rok4.Utils import *
+from unittest.mock import *
+from unittest import mock
 
+from rok4.utils import *
+from rok4.exceptions import *
 
 def test_srs_to_spatialreference_ignf_ok():
     try:
@@ -74,7 +73,7 @@ def test_reproject_point_ok():
         assert False, f"Bbox reprojection raises an exception: {exc}"
 
 
-# Tests for the rok4.Utils.compute_bbox function.
+# Tests for the rok4.utils.compute_bbox function.
 
 
 def test_compute_bbox_epsg_3857_ok():
@@ -215,13 +214,13 @@ def test_compute_bbox_no_srs_ok():
         assert False, f"Bbox computation raises an exception: {exc}"
 
 
-# Tests for the rok4.Utils.compute_format function.
+# Tests for the rok4.utils.compute_format function.
 
 
-@mock.patch("rok4.Utils.gdal.Info")
-@mock.patch("rok4.Utils.gdal.GetColorInterpretationName", return_value="Palette")
-@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=8)
-@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="Byte")
+@mock.patch("rok4.utils.gdal.Info")
+@mock.patch("rok4.utils.gdal.GetColorInterpretationName", return_value="Palette")
+@mock.patch("rok4.utils.gdal.GetDataTypeSize", return_value=8)
+@mock.patch("rok4.utils.gdal.GetDataTypeName", return_value="Byte")
 def test_compute_format_bit_ok(
     mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
 ):
@@ -247,10 +246,10 @@ def test_compute_format_bit_ok(
         assert False, f"Color format computation raises an exception: {exc}"
 
 
-@mock.patch("rok4.Utils.gdal.Info")
-@mock.patch("rok4.Utils.gdal.GetColorInterpretationName")
-@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=8)
-@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="Byte")
+@mock.patch("rok4.utils.gdal.Info")
+@mock.patch("rok4.utils.gdal.GetColorInterpretationName")
+@mock.patch("rok4.utils.gdal.GetDataTypeSize", return_value=8)
+@mock.patch("rok4.utils.gdal.GetDataTypeName", return_value="Byte")
 def test_compute_format_uint8_ok(
     mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
 ):
@@ -284,10 +283,10 @@ def test_compute_format_uint8_ok(
         assert False, f"Color format computation raises an exception: {exc}"
 
 
-@mock.patch("rok4.Utils.gdal.Info")
-@mock.patch("rok4.Utils.gdal.GetColorInterpretationName")
-@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=32)
-@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="Float32")
+@mock.patch("rok4.utils.gdal.Info")
+@mock.patch("rok4.utils.gdal.GetColorInterpretationName")
+@mock.patch("rok4.utils.gdal.GetDataTypeSize", return_value=32)
+@mock.patch("rok4.utils.gdal.GetDataTypeName", return_value="Float32")
 def test_compute_format_float32_ok(
     mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
 ):
@@ -321,10 +320,10 @@ def test_compute_format_float32_ok(
         assert False, f"Color format computation raises an exception: {exc}"
 
 
-@mock.patch("rok4.Utils.gdal.Info")
-@mock.patch("rok4.Utils.gdal.GetColorInterpretationName")
-@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=16)
-@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="UInt16")
+@mock.patch("rok4.utils.gdal.Info")
+@mock.patch("rok4.utils.gdal.GetColorInterpretationName")
+@mock.patch("rok4.utils.gdal.GetDataTypeSize", return_value=16)
+@mock.patch("rok4.utils.gdal.GetDataTypeName", return_value="UInt16")
 def test_compute_format_unsupported_nok(
     mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
 ):
@@ -358,10 +357,10 @@ def test_compute_format_unsupported_nok(
         assert False, f"Color format computation raises an exception: {exc}"
 
 
-@mock.patch("rok4.Utils.gdal.Info")
-@mock.patch("rok4.Utils.gdal.GetColorInterpretationName")
-@mock.patch("rok4.Utils.gdal.GetDataTypeSize", return_value=16)
-@mock.patch("rok4.Utils.gdal.GetDataTypeName", return_value="UInt16")
+@mock.patch("rok4.utils.gdal.Info")
+@mock.patch("rok4.utils.gdal.GetColorInterpretationName")
+@mock.patch("rok4.utils.gdal.GetDataTypeSize", return_value=16)
+@mock.patch("rok4.utils.gdal.GetDataTypeName", return_value="UInt16")
 def test_compute_format_no_band_nok(
     mocked_GetDataTypeName, mocked_GetDataTypeSize, mocked_GetColorInterpretationName, mocked_Info
 ):
diff --git a/tests/test_Vector.py b/tests/test_vector.py
similarity index 92%
rename from tests/test_Vector.py
rename to tests/test_vector.py
index 3fe0a1c..513c559 100644
--- a/tests/test_Vector.py
+++ b/tests/test_vector.py
@@ -1,14 +1,11 @@
-#!/usr/bin/env python3
+import pytest
 import os
-from unittest import mock
 from unittest.mock import *
+from unittest import mock
 
-import pytest
-
-from rok4.Exceptions import *
-from rok4.Storage import disconnect_ceph_clients
-from rok4.Vector import *
-
+from rok4.vector import *
+from rok4.exceptions import *
+from rok4.storage import disconnect_ceph_clients
 
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_missing_env():
@@ -17,7 +14,7 @@ def test_missing_env():
         vector = Vector.from_file("ceph:///ign_std/vector.shp")
 
 
-@mock.patch("rok4.Vector.copy", side_effect=StorageError("CEPH", "Not found"))
+@mock.patch("rok4.vector.copy", side_effect=StorageError("CEPH", "Not found"))
 def test_wrong_file(mocked_copy):
     with pytest.raises(StorageError):
         vector = Vector.from_file("ceph:///vector.geojson")
@@ -29,15 +26,15 @@ def test_wrong_format():
     assert str(exc.value) == "This format of file cannot be loaded"
 
 
-@mock.patch("rok4.Vector.ogr.Open", return_value="not a shape")
+@mock.patch("rok4.vector.ogr.Open", return_value="not a shape")
 def test_wrong_content(mocked_copy):
     with pytest.raises(Exception) as exc:
         vector = Vector.from_file("file:///vector.shp")
     assert str(exc.value) == "The content of file:///vector.shp cannot be read"
 
 
-@mock.patch("rok4.Vector.copy")
-@mock.patch("rok4.Vector.ogr.Open", return_value="not a shape")
+@mock.patch("rok4.vector.copy")
+@mock.patch("rok4.vector.ogr.Open", return_value="not a shape")
 def test_wrong_content_ceph(mocked_open, mocked_copy):
     with pytest.raises(Exception) as exc:
         vector = Vector.from_file("file:///vector.shp")

From bc67460466fa4d5263990927ee7675d091fdc2e2 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Tue, 18 Jul 2023 23:24:26 +0200
Subject: [PATCH 66/89] Suppression de l'ancien fichier des classes Pyramid et
 Level

---
 src/rok4/Pyramid.py | 1385 -------------------------------------------
 src/rok4/pyramid.py |    4 +-
 2 files changed, 3 insertions(+), 1386 deletions(-)
 delete mode 100644 src/rok4/Pyramid.py

diff --git a/src/rok4/Pyramid.py b/src/rok4/Pyramid.py
deleted file mode 100644
index 19fa9c7..0000000
--- a/src/rok4/Pyramid.py
+++ /dev/null
@@ -1,1385 +0,0 @@
-"""Provide classes to use pyramid's data.
-
-The module contains the following classes:
-
-- `Pyramid` - Data container
-- `Level` - Level of a pyramid
-"""
-
-from typing import Dict, List, Tuple, Union, Iterator
-import json
-from json.decoder import JSONDecodeError
-import os
-import re
-import numpy
-import zlib
-import io
-import mapbox_vector_tile
-from PIL import Image
-
-from rok4.Exceptions import *
-from rok4.tile_matrix_set import TileMatrixSet, TileMatrix
-from rok4.storage import *
-from rok4.utils import *
-from rok4.enums import StorageType
-
-
-class PyramidType(Enum):
-    """Pyramid's data type"""
-
-    RASTER = "RASTER"
-    VECTOR = "VECTOR"
-
-
-class SlabType(Enum):
-    """Slab's type"""
-
-    DATA = "DATA"  # Slab of data, raster or vector
-    MASK = "MASK"  # Slab of mask, only for raster pyramid, image with one band : 0 is nodata, other values are data
-
-
-ROK4_IMAGE_HEADER_SIZE = 2048
-"""Slab's header size, 2048 bytes"""
-
-
-def b36_number_encode(number: int) -> str:
-    """Convert base-10 number to base-36
-
-    Used alphabet is '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-
-    Args:
-        number (int): base-10 number
-
-    Returns:
-        str: base-36 number
-    """
-
-    alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-    base36 = ""
-
-    if 0 <= number < len(alphabet):
-        return alphabet[number]
-
-    while number != 0:
-        number, i = divmod(number, len(alphabet))
-        base36 = alphabet[i] + base36
-
-    return base36
-
-
-def b36_number_decode(number: str) -> int:
-    """Convert base-36 number to base-10
-
-    Args:
-        number (str): base-36 number
-
-    Returns:
-        int: base-10 number
-    """
-    return int(number, 36)
-
-
-def b36_path_decode(path: str) -> Tuple[int, int]:
-    """Get slab's column and row from a base-36 based path
-
-    Args:
-        path (str): slab's path
-
-    Returns:
-        Tuple[int, int]: slab's column and row
-    """
-
-    path = path.replace("/", "")
-    path = re.sub(r"(\.TIFF?)", "", path.upper())
-
-    b36_column = ""
-    b36_row = ""
-
-    while len(path) > 0:
-        b36_column += path[0]
-        b36_row += path[1]
-        path = path[2:]
-
-    return b36_number_decode(b36_column), b36_number_decode(b36_row)
-
-
-def b36_path_encode(column: int, row: int, slashs: int) -> str:
-    """Convert slab indices to base-36 based path, with .tif extension
-
-    Args:
-        column (int): slab's column
-        row (int): slab's row
-        slashs (int): slashs' number (to split path)
-
-    Returns:
-        str: base-36 based path
-    """
-
-    b36_column = b36_number_encode(column)
-    b36_row = b36_number_encode(row)
-
-    max_len = max(slashs + 1, len(b36_column), len(b36_row))
-
-    b36_column = b36_column.rjust(max_len, "0")
-    b36_row = b36_row.rjust(max_len, "0")
-
-    b36_path = ""
-
-    while len(b36_column) > 0:
-        b36_path = b36_row[-1] + b36_path
-        b36_path = b36_column[-1] + b36_path
-
-        b36_column = b36_column[:-1]
-        b36_row = b36_row[:-1]
-
-        if slashs > 0:
-            b36_path = "/" + b36_path
-            slashs -= 1
-
-    return f"{b36_path}.tif"
-
-
-class Level:
-    """A pyramid's level, raster or vector
-
-    Attributes:
-        __id (str): level's identifier. have to exist in the pyramid's used TMS
-        __tile_limits (Dict[str, int]): minimum and maximum tiles' columns and rows of pyramid's content
-        __slab_size (Tuple[int, int]): number of tile in a slab, widthwise and heightwise
-        __tables (List[Dict]): for a VECTOR pyramid, description of vector content, tables and attributes
-    """
-
-    @classmethod
-    def from_descriptor(cls, data: Dict, pyramid: "Pyramid") -> "Level":
-        """Create a pyramid's level from the pyramid's descriptor levels element
-
-        Args:
-            data (Dict): level's information from the pyramid's descriptor
-            pyramid (Pyramid): pyramid containing the level to create
-
-        Raises:
-            Exception: different storage or masks presence between the level and the pyramid
-            MissingAttributeError: Attribute is missing in the content
-
-        Returns:
-            Pyramid: a Level instance
-        """
-        level = cls()
-
-        level.__pyramid = pyramid
-
-        # Attributs communs
-        try:
-            level.__id = data["id"]
-            level.__tile_limits = data["tile_limits"]
-            level.__slab_size = (
-                data["tiles_per_width"],
-                data["tiles_per_height"],
-            )
-
-            # Informations sur le stockage : on les valide et stocke dans la pyramide
-            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 "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"
-                    )
-            else:
-                if pyramid.own_masks:
-                    raise Exception(
-                        f"Pyramid {pyramid.__descriptor} define a mask format but level {level.__id} does not define mask storage informations"
-                    )
-
-        except KeyError as e:
-            raise MissingAttributeError(pyramid.descriptor, f"levels[].{e}")
-
-        # Attributs dans le cas d'un niveau vecteur
-        if level.__pyramid.type == PyramidType.VECTOR:
-            try:
-                level.__tables = data["tables"]
-
-            except KeyError as e:
-                raise MissingAttributeError(pyramid.descriptor, f"levels[].{e}")
-
-        return level
-
-    @classmethod
-    def from_other(cls, other: "Level", pyramid: "Pyramid") -> "Level":
-        """Create a pyramid's level from another one
-
-        Args:
-            other (Level): level to clone
-            pyramid (Pyramid): new pyramid containing the new level
-
-        Raises:
-            Exception: different storage or masks presence between the level and the pyramid
-            MissingAttributeError: Attribute is missing in the content
-
-        Returns:
-            Pyramid: a Level instance
-        """
-
-        level = cls()
-
-        # Attributs communs
-        level.__id = other.__id
-        level.__pyramid = pyramid
-        level.__tile_limits = other.__tile_limits
-        level.__slab_size = other.__slab_size
-
-        # Attributs dans le cas d'un niveau vecteur
-        if level.__pyramid.type == PyramidType.VECTOR:
-            level.__tables = other.__tables
-
-        return level
-
-    def __str__(self) -> str:
-        return f"{self.__pyramid.type.name} pyramid's level '{self.__id}' ({self.__pyramid.storage_type.name} storage)"
-
-    @property
-    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],
-            "tiles_per_height": self.__slab_size[1],
-            "tile_limits": self.__tile_limits,
-        }
-
-        if self.__pyramid.type == PyramidType.VECTOR:
-            serialization["tables"] = self.__tables
-
-        if self.__pyramid.storage_type == StorageType.FILE:
-            serialization["storage"] = {
-                "type": "FILE",
-                "image_directory": f"{self.__pyramid.name}/DATA/{self.__id}",
-                "path_depth": self.__pyramid.storage_depth,
-            }
-            if self.__pyramid.own_masks:
-                serialization["storage"][
-                    "mask_directory"
-                ] = f"{self.__pyramid.name}/MASK/{self.__id}"
-
-        elif self.__pyramid.storage_type == StorageType.CEPH:
-            serialization["storage"] = {
-                "type": "CEPH",
-                "image_prefix": f"{self.__pyramid.name}/DATA_{self.__id}",
-                "pool_name": self.__pyramid.storage_root,
-            }
-            if self.__pyramid.own_masks:
-                serialization["storage"]["mask_prefix"] = f"{self.__pyramid.name}/MASK_{self.__id}"
-
-        elif self.__pyramid.storage_type == StorageType.S3:
-            serialization["storage"] = {
-                "type": "S3",
-                "image_prefix": f"{self.__pyramid.name}/DATA_{self.__id}",
-                "bucket_name": self.__pyramid.storage_root,
-            }
-            if self.__pyramid.own_masks:
-                serialization["storage"]["mask_prefix"] = f"{self.__pyramid.name}/MASK_{self.__id}"
-
-        return serialization
-
-    @property
-    def id(self) -> str:
-        return self.__id
-
-    @property
-    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"]
-        )
-        max_bbox = self.__pyramid.tms.get_level(self.__id).tile_to_bbox(
-            self.__tile_limits["max_col"], self.__tile_limits["min_row"]
-        )
-
-        return (min_bbox[0], min_bbox[1], max_bbox[2], max_bbox[3])
-
-    @property
-    def resolution(self) -> str:
-        return self.__pyramid.tms.get_level(self.__id).resolution
-
-    @property
-    def tile_matrix(self) -> TileMatrix:
-        return self.__pyramid.tms.get_level(self.__id)
-
-    @property
-    def slab_width(self) -> int:
-        return self.__slab_size[0]
-
-    @property
-    def slab_height(self) -> int:
-        return self.__slab_size[1]
-
-    def is_in_limits(self, column: int, row: int) -> bool:
-        """Is the tile indices in limits ?
-
-        Args:
-            column (int): tile's column
-            row (int): tile's row
-
-        Returns:
-            bool: True if tiles' limits contain the provided tile's indices
-        """
-        return (
-            self.__tile_limits["min_row"] <= row
-            and self.__tile_limits["max_row"] >= row
-            and self.__tile_limits["min_col"] <= column
-            and self.__tile_limits["max_col"] >= column
-        )
-
-    def set_limits_from_bbox(self, bbox: Tuple[float, float, float, float]) -> None:
-        """Set tile limits, based on provided bounding box
-
-        Args:
-            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,
-            "max_col": col_max,
-            "max_row": row_max,
-            "min_col": col_min,
-        }
-
-
-class Pyramid:
-
-    """A data pyramid, raster or vector
-
-    Attributes:
-        __name (str): pyramid's name
-        __descriptor (str): pyramid's descriptor path
-        __list (str): pyramid's list path
-        __tms (rok4.tile_matrix_set.TileMatrixSet): Used grid
-        __levels (Dict[str, Level]): Pyramid's levels
-        __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).
-
-            Example (S3 storage):
-
-                {
-                    'cache': {
-                        (<SlabType.DATA: 'DATA'>, '18', 5424, 7526): {
-                            'link': False,
-                            'md5': None,
-                            'root': 'pyramids@localhost:9000/LIMADM',
-                            'slab': 'DATA_18_5424_7526'
-                        }
-                    },
-                    'loaded': True
-                }
-    """
-
-    @classmethod
-    def from_descriptor(cls, descriptor: str) -> "Pyramid":
-        """Create a pyramid from its descriptor
-
-        Args:
-            descriptor (str): pyramid's descriptor path
-
-        Raises:
-            FormatError: Provided path or the TMS is not a well formed JSON
-            Exception: Level issue : no one in the pyramid or the used TMS, or level ID not defined in the TMS
-            MissingAttributeError: Attribute is missing in the content
-            StorageError: Storage read issue (pyramid descriptor or TMS)
-            MissingEnvironmentError: Missing object storage informations or TMS root directory
-
-        Examples:
-
-            S3 stored descriptor
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
-                except Exception as e:
-                    print("Cannot load the pyramid from its descriptor")
-
-        Returns:
-            Pyramid: a Pyramid instance
-        """
-        try:
-            data = json.loads(get_data_str(descriptor))
-
-        except JSONDecodeError as e:
-            raise FormatError("JSON", descriptor, e)
-
-        pyramid = cls()
-
-        pyramid.__storage["type"], path, pyramid.__storage["root"], base_name = get_infos_from_path(
-            descriptor
-        )
-        pyramid.__name = base_name[:-5]  # on supprime l'extension.json
-        pyramid.__descriptor = descriptor
-        pyramid.__list = get_path_from_infos(
-            pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.list"
-        )
-
-        try:
-            # Attributs communs
-            pyramid.__tms = TileMatrixSet(data["tile_matrix_set"])
-            pyramid.__format = data["format"]
-
-            # Attributs d'une pyramide raster
-            if pyramid.type == PyramidType.RASTER:
-                pyramid.__raster_specifications = data["raster_specifications"]
-
-                if "mask_format" in data:
-                    pyramid.__masks = True
-                else:
-                    pyramid.__masks = False
-
-            # Niveaux
-            for l in data["levels"]:
-                lev = Level.from_descriptor(l, pyramid)
-                pyramid.__levels[lev.id] = lev
-
-                if pyramid.__tms.get_level(lev.id) is None:
-                    raise Exception(
-                        f"Pyramid {descriptor} owns a level with the ID '{lev.id}', not defined in the TMS '{pyramid.tms.name}'"
-                    )
-
-        except KeyError as e:
-            raise MissingAttributeError(descriptor, e)
-
-        if len(pyramid.__levels.keys()) == 0:
-            raise Exception(f"Pyramid '{descriptor}' has no level")
-
-        return pyramid
-
-    @classmethod
-    def from_other(cls, other: "Pyramid", name: str, storage: Dict) -> "Pyramid":
-        """Create a pyramid from another one
-
-        Args:
-            other (Pyramid): pyramid to clone
-            name (str): new pyramid's name
-            storage (Dict[str, Union[str, int]]): new pyramid's storage informations
-
-        Raises:
-            FormatError: Provided path or the TMS is not a well formed JSON
-            Exception: Level issue : no one in the pyramid or the used TMS, or level ID not defined in the TMS
-            MissingAttributeError: Attribute is missing in the content
-
-        Returns:
-            Pyramid: a Pyramid instance
-        """
-        try:
-            # On convertit le type de stockage selon l'énumération
-            storage["type"] = StorageType[storage["type"]]
-
-            if storage["type"] == StorageType.FILE and name.find("/") != -1:
-                raise Exception(f"A FILE stored pyramid's name cannot contain '/' : '{name}'")
-
-            if storage["type"] == StorageType.FILE and "depth" not in storage:
-                storage["depth"] = 2
-
-            pyramid = cls()
-
-            # Attributs communs
-            pyramid.__name = name
-            pyramid.__storage = storage
-            pyramid.__masks = other.__masks
-
-            pyramid.__descriptor = get_path_from_infos(
-                pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.json"
-            )
-            pyramid.__list = get_path_from_infos(
-                pyramid.__storage["type"], pyramid.__storage["root"], f"{pyramid.__name}.list"
-            )
-            pyramid.__tms = other.__tms
-            pyramid.__format = other.__format
-
-            # Attributs d'une pyramide raster
-            if pyramid.type == PyramidType.RASTER:
-                if other.own_masks:
-                    pyramid.__masks = True
-                else:
-                    pyramid.__masks = False
-                pyramid.__raster_specifications = other.__raster_specifications
-
-            # Niveaux
-            for l in other.__levels.values():
-                lev = Level.from_other(l, pyramid)
-                pyramid.__levels[lev.id] = lev
-
-        except KeyError as e:
-            raise MissingAttributeError(descriptor, e)
-
-        return pyramid
-
-    def __init__(self) -> None:
-        self.__storage = {}
-        self.__levels = {}
-        self.__masks = None
-
-        self.__content = {"loaded": False, "cache": {}}
-
-    def __str__(self) -> str:
-        return f"{self.type.name} pyramid '{self.__name}' ({self.__storage['type'].name} storage)"
-
-    @property
-    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
-        }
-
-        serialization["levels"] = []
-        sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
-
-        for l in sorted_levels:
-            serialization["levels"].append(l.serializable)
-
-        if self.type == PyramidType.RASTER:
-            serialization["raster_specifications"] = self.__raster_specifications
-
-        if self.__masks:
-            serialization["mask_format"] = "TIFF_ZIP_UINT8"
-
-        return serialization
-
-    @property
-    def list(self) -> str:
-        return self.__list
-
-    @property
-    def descriptor(self) -> str:
-        return self.__descriptor
-
-    @property
-    def name(self) -> str:
-        return self.__name
-
-    @property
-    def tms(self) -> TileMatrixSet:
-        return self.__tms
-
-    @property
-    def raster_specifications(self) -> Dict:
-        """Get raster specifications for a RASTER pyramid
-
-        Example:
-            {
-                "channels": 3,
-                "nodata": "255,0,0",
-                "photometric": "rgb",
-                "interpolation": "bicubic"
-            }
-
-        Returns:
-            Dict: Raster specifications, None if VECTOR pyramid
-        """
-        return self.__raster_specifications
-
-    @property
-    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:
-        """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:
-        return self.__storage.get("depth", None)
-
-    @property
-    def storage_s3_cluster(self) -> str:
-        """Get the pyramid's storage S3 cluster (host name)
-
-        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]
-            except IndexError:
-                return None
-        else:
-            return None
-
-    @storage_depth.setter
-    def storage_depth(self, d: int) -> None:
-        """Set the tree depth for a FILE storage
-
-        Args:
-            d (int): file storage depth
-
-        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
-
-    @property
-    def own_masks(self) -> bool:
-        return self.__masks
-
-    @property
-    def format(self) -> str:
-        return self.__format
-
-    @property
-    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"]:
-            return "jpg"
-        elif self.__format == "TIFF_PNG_UINT8":
-            return "png"
-        elif self.__format == "TIFF_PBF_MVT":
-            return "pbf"
-        else:
-            raise Exception(
-                f"Unknown pyramid's format ({self.__format}), cannot return the tile extension"
-            )
-
-    @property
-    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
-    def top_level(self) -> "Level":
-        """Get the low resolution level in the pyramid
-
-        Returns:
-            Level: the top level
-        """
-        return sorted(self.__levels.values(), key=lambda l: l.resolution)[-1]
-
-    @property
-    def type(self) -> PyramidType:
-        """Get the pyramid's type (RASTER or VECTOR) from its format
-
-        Returns:
-            PyramidType: RASTER or VECTOR
-        """
-        if self.__format == "TIFF_PBF_MVT":
-            return PyramidType.VECTOR
-        else:
-            return PyramidType.RASTER
-
-    def load_list(self) -> None:
-        """Load list content and cache it
-
-        If list is already loaded, nothing done
-        """
-        if self.__content["loaded"]:
-            return
-
-        for slab, infos in self.list_generator():
-            self.__content["cache"][slab] = infos
-
-        self.__content["loaded"] = True
-
-    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
-
-        Examples:
-
-            S3 stored descriptor
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
-
-                    for (slab_type, level, column, row), infos in pyramid.list_generator():
-                        print(infos)
-
-                except Exception as e:
-                    print("Cannot load the pyramid from its descriptor and read the list")
-
-        Yields:
-            Iterator[Tuple[Tuple[SlabType,str,int,int], Dict]]: Slab indices and storage informations
-
-            Value example:
-
-                (
-                    (<SlabType.DATA: 'DATA'>, '18', 5424, 7526),
-                    {
-                        'link': False,
-                        'md5': None,
-                        'root': 'pyramids@localhost:9000/LIMADM',
-                        'slab': 'DATA_18_5424_7526'
-                    }
-                )
-
-        """
-        if self.__content["loaded"]:
-            for slab, infos in self.__content["cache"].items():
-                yield slab, infos
-        else:
-            # Copie de la liste dans un fichier temporaire (cette liste peut être un objet)
-            list_obj = tempfile.NamedTemporaryFile(mode="r", delete=False)
-            list_file = list_obj.name
-            copy(self.__list, f"file://{list_file}")
-            list_obj.close()
-
-            roots = {}
-            s3_cluster = self.storage_s3_cluster
-
-            with open(list_file, "r") as listin:
-                # Lecture des racines
-                for line in listin:
-                    line = line.rstrip()
-
-                    if line == "#":
-                        break
-
-                    root_id, root_path = line.split("=", 1)
-
-                    if s3_cluster is None:
-                        roots[root_id] = root_path
-                    else:
-                        # On a un nom de cluster S3, on l'ajoute au nom du bucket dans les racines
-                        root_bucket, root_path = root_path.split("/", 1)
-                        roots[root_id] = f"{root_bucket}@{s3_cluster}/{root_path}"
-
-                # Lecture des dalles
-                for line in listin:
-                    line = line.rstrip()
-
-                    parts = line.split(" ", 1)
-                    slab_path = parts[0]
-                    slab_md5 = None
-                    if len(parts) == 2:
-                        slab_md5 = parts[1]
-
-                    root_id, slab_path = slab_path.split("/", 1)
-
-                    slab_type, level, column, row = self.get_infos_from_slab_path(slab_path)
-                    infos = {
-                        "root": roots[root_id],
-                        "link": root_id != "0",
-                        "slab": slab_path,
-                        "md5": slab_md5,
-                    }
-
-                    yield ((slab_type, level, column, row), infos)
-
-            remove(f"file://{list_file}")
-
-    def get_level(self, level_id: str) -> "Level":
-        """Get one level according to its identifier
-
-        Args:
-            level_id: Level identifier
-
-        Returns:
-            The corresponding pyramid's level, None if not present
-        """
-        
-        return self.__levels.get(level_id, None)
-
-    def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
-        """Get sorted levels in the provided range from bottom to top
-
-        Args:
-            bottom_id (str, optionnal): specific bottom level id. Defaults to None.
-            top_id (str, optionnal): specific top level id. Defaults to None.
-
-        Raises:
-            Exception: Provided levels are not consistent (bottom > top or not in the pyramid)
-
-        Examples:
-
-            All levels
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
-                    levels = pyramid.get_levels()
-
-                except Exception as e:
-                    print("Cannot load the pyramid from its descriptor and get levels")
-
-            From pyramid's bottom to provided top (level 5)
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
-                    levels = pyramid.get_levels(None, "5")
-
-                except Exception as e:
-                    print("Cannot load the pyramid from its descriptor and get levels")
-
-        Returns:
-            List[Level]: asked sorted levels
-        """
-
-        sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution)
-
-        levels = []
-
-        begin = False
-        if bottom_id is None:
-            # Pas de niveau du bas fourni, on commence tout en bas
-            begin = True
-        else:
-            if self.get_level(bottom_id) is None:
-                raise Exception(
-                    f"Pyramid {self.name} does not contain the provided bottom level {bottom_id}"
-                )
-
-        if top_id is not None and self.get_level(top_id) is None:
-            raise Exception(f"Pyramid {self.name} does not contain the provided top level {top_id}")
-
-        end = False
-
-        for l in sorted_levels:
-            if not begin and l.id == bottom_id:
-                begin = True
-
-            if begin:
-                levels.append(l)
-                if top_id is not None and l.id == top_id:
-                    end = True
-                    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)
-
-    def get_infos_from_slab_path(self, path: str) -> Tuple[SlabType, str, int, int]:
-        """Get the slab's indices from its storage path
-
-        Args:
-            path (str): Slab's storage path
-
-        Examples:
-
-            FILE stored pyramid
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("/path/to/descriptor.json")
-                    slab_type, level, column, row = self.get_infos_from_slab_path("DATA/12/00/4A/F7.tif")
-                    # (SlabType.DATA, "12", 159, 367)
-                except Exception as e:
-                    print("Cannot load the pyramid from its descriptor and convert a slab path")
-
-            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")
-                    # (SlabType.MASK, "15", 9164, 5846)
-                except Exception as e:
-                    print("Cannot load the pyramid from its descriptor and convert a slab path")
-
-        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("/")
-
-            # Le partie du chemin qui contient la colonne et ligne de la dalle est à la fin, en fonction de la profondeur choisie
-            # depth = 2 -> on doit utiliser les 3 dernières parties pour la conversion
-            column, row = b36_path_decode("/".join(parts[-(self.__storage["depth"] + 1) :]))
-            level = parts[-(self.__storage["depth"] + 2)]
-            raw_slab_type = parts[-(self.__storage["depth"] + 3)]
-
-            # Pour être retro compatible avec l'ancien nommage
-            if raw_slab_type == "IMAGE":
-                raw_slab_type = "DATA"
-
-            slab_type = SlabType[raw_slab_type]
-
-            return slab_type, level, column, row
-        else:
-            parts = re.split(r"[/_]", path)
-            column = parts[-2]
-            row = parts[-1]
-            level = parts[-3]
-            raw_slab_type = parts[-4]
-
-            # Pour être retro compatible avec l'ancien nommage
-            if raw_slab_type == "IMG":
-                raw_slab_type = "DATA"
-            elif raw_slab_type == "MSK":
-                raw_slab_type = "MASK"
-
-            slab_type = SlabType[raw_slab_type]
-
-            return slab_type, level, int(column), int(row)
-
-    def get_slab_path_from_infos(
-        self, slab_type: SlabType, level: str, column: int, row: int, full: bool = True
-    ) -> str:
-        """Get slab's storage path from the indices
-
-        Args:
-            slab_type (SlabType): DATA or MASK
-            level (str): Level identifier
-            column (int): Slab's column
-            row (int): Slab's row
-            full (bool, optional): Full path or just relative path from pyramid storage root. Defaults to True.
-
-        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
-
-        To get a tile, 3 steps :
-            * calculate slab path from tile index
-            * read slab index to get offsets and sizes of slab's tiles
-            * read the tile into the slab
-
-        Args:
-            level (str): Tile's level
-            column (int): Tile's column
-            row (int): Tile's row
-
-        Limitations:
-            Pyramids with one-tile slab are not handled
-
-        Examples:
-
-            FILE stored raster pyramid, to extract a tile containing a point and save it as independent image
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("/data/pyramids/SCAN1000.json")
-                    level, col, row, pcol, prow = pyramid.get_tile_indices(992904.46, 6733643.15, "9", srs = "IGNF:LAMB93")
-                    data = pyramid.get_tile_data_binary(level, col, row)
-
-                    if data is None:
-                        print("No data")
-                    else:
-                        tile_name = f"tile_{level}_{col}_{row}.{pyramid.tile_extension}"
-                        with open(tile_name, "wb") as image:
-                            image.write(data)
-                        print (f"Tile written in {tile_name}")
-
-                except Exception as e:
-                    print("Cannot save a pyramid's tile : {e}")
-
-        Raises:
-            Exception: Level not found in the pyramid
-            NotImplementedError: Pyramid owns one-tile slabs
-            MissingEnvironmentError: Missing object storage informations
-            StorageError: Storage read issue
-
-        Returns:
-            str: data, as binary string, None if no data
-        """
-
-        level_object = self.get_level(level)
-
-        if level_object is None:
-            raise Exception(f"No level {level} in the pyramid")
-
-        if level_object.slab_width == 1 and level_object.slab_height == 1:
-            raise NotImplementedError(f"One-tile slab pyramid is not handled")
-
-        if not level_object.is_in_limits(column, row):
-            return None
-
-        # Indices de la dalle
-        slab_column = column // level_object.slab_width
-        slab_row = row // level_object.slab_height
-
-        # Indices de la tuile dans la dalle
-        relative_tile_column = column % level_object.slab_width
-        relative_tile_row = row % level_object.slab_height
-
-        # Numéro de la tuile dans le header
-        tile_index = relative_tile_row * level_object.slab_width + relative_tile_column
-
-        # Calcul du chemin de la dalle contenant la tuile voulue
-        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,
-        # puis sont stockés les offsets (chacun sur 4 octets)
-        # puis les tailles (chacune sur 4 octets)
-        try:
-            binary_index = get_data_binary(
-                slab_path,
-                (
-                    ROK4_IMAGE_HEADER_SIZE,
-                    2 * 4 * level_object.slab_width * level_object.slab_height,
-                ),
-            )
-        except FileNotFoundError as e:
-            # L'absence de la dalle est gérée comme simplement une absence de données
-            return None
-
-        offsets = numpy.frombuffer(
-            binary_index,
-            dtype=numpy.dtype("uint32"),
-            count=level_object.slab_width * level_object.slab_height,
-        )
-        sizes = numpy.frombuffer(
-            binary_index,
-            dtype=numpy.dtype("uint32"),
-            offset=4 * level_object.slab_width * level_object.slab_height,
-            count=level_object.slab_width * level_object.slab_height,
-        )
-
-        if sizes[tile_index] == 0:
-            return None
-
-        return get_data_binary(slab_path, (offsets[tile_index], sizes[tile_index]))
-
-    def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarray:
-        """Get a raster pyramid's tile as 3-dimension numpy ndarray
-
-        First dimension is the row, second one is column, third one is band.
-
-        Args:
-            level (str): Tile's level
-            column (int): Tile's column
-            row (int): Tile's row
-
-        Limitations:
-            Packbits (pyramid formats TIFF_PKB_FLOAT32 and TIFF_PKB_UINT8) and LZW (pyramid formats TIFF_LZW_FLOAT32 and TIFF_LZW_UINT8) compressions are not handled.
-
-        Raises:
-            Exception: Cannot get raster data for a vector pyramid
-            Exception: Level not found in the pyramid
-            NotImplementedError: Pyramid owns one-tile slabs
-            NotImplementedError: Raster pyramid format not handled
-            MissingEnvironmentError: Missing object storage informations
-            StorageError: Storage read issue
-            FormatError: Cannot decode tile
-
-        Examples:
-
-            FILE stored DTM (raster) pyramid, to get the altitude value at a point in the best level
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("/data/pyramids/RGEALTI.json")
-                    level, col, row, pcol, prow = pyramid.get_tile_indices(44, 5, srs = "EPSG:4326")
-                    data = pyramid.get_tile_data_raster(level, col, row)
-
-                    if data is None:
-                        print("No data")
-                    else:
-                        print(data[prow][pcol])
-
-                except Exception as e:
-                    print("Cannot get a pyramid's pixel value : {e}")
-
-        Returns:
-            str: data, as numpy array, None if no data
-        """
-
-        if self.type == PyramidType.VECTOR:
-            raise Exception("Cannot get tile as raster data : it's a vector pyramid")
-
-        binary_tile = self.get_tile_data_binary(level, column, row)
-
-        if binary_tile is None:
-            return None
-
-        level_object = self.get_level(level)
-
-        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":
-            data = numpy.frombuffer(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"],
-            )
-
-        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":
-            try:
-                data = numpy.frombuffer(zlib.decompress(binary_tile), dtype=numpy.dtype("uint8"))
-            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"],
-            )
-
-        elif self.__format == "TIFF_ZIP_FLOAT32":
-            try:
-                data = numpy.frombuffer(zlib.decompress(binary_tile), dtype=numpy.dtype("float32"))
-            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"],
-            )
-
-        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"],
-            )
-
-        else:
-            raise NotImplementedError(f"Cannot get tile as raster data for format {self.__format}")
-
-        return data
-
-    def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
-        """Get a vector pyramid's tile as GeoJSON dictionnary
-
-        Args:
-            level (str): Tile's level
-            column (int): Tile's column
-            row (int): Tile's row
-
-        Raises:
-            Exception: Cannot get vector data for a raster pyramid
-            Exception: Level not found in the pyramid
-            NotImplementedError: Pyramid owns one-tile slabs
-            NotImplementedError: Vector pyramid format not handled
-            MissingEnvironmentError: Missing object storage informations
-            StorageError: Storage read issue
-            FormatError: Cannot decode tile
-
-        Examples:
-
-            S3 stored vector pyramid, to print a tile as GeoJSON
-
-                from rok4.pyramid import Pyramid
-                import json
-
-                try:
-                    pyramid = Pyramid.from_descriptor("s3://pyramids/vectors/BDTOPO.json")
-                    level, col, row, pcol, prow = pyramid.get_tile_indices(40.325, 3.123, srs = "EPSG:4326")
-                    data = pyramid.get_tile_data_vector(level, col, row)
-
-                    if data is None:
-                        print("No data")
-                    else:
-                        print(json.dumps(data))
-
-                except Exception as e:
-                    print("Cannot print a vector pyramid's tile as GeoJSON : {e}")
-
-        Returns:
-            str: data, as GeoJSON dictionnary. None if no data
-        """
-
-        if self.type == PyramidType.RASTER:
-            raise Exception("Cannot get tile as vector data : it's a raster pyramid")
-
-        binary_tile = self.get_tile_data_binary(level, column, row)
-
-        if binary_tile is None:
-            return None
-
-        level_object = self.get_level(level)
-
-        if self.__format == "TIFF_PBF_MVT":
-            try:
-                data = mapbox_vector_tile.decode(binary_tile)
-            except Exception as e:
-                raise FormatError("PBF (MVT)", "binary tile", e)
-        else:
-            raise NotImplementedError(f"Cannot get tile as vector data for format {self.__format}")
-
-        return data
-
-    def get_tile_indices(
-        self, x: float, y: float, level: str = None, **kwargs
-    ) -> Tuple[str, int, int, int, int]:
-        """Get pyramid's tile and pixel indices from point's coordinates
-
-        Used coordinates system have to be the pyramid one. If EPSG:4326, x is latitude and y longitude.
-
-        Args:
-            x (float): point's x
-            y (float): point's y
-            level (str, optional): Pyramid's level to take into account, the bottom one if None . Defaults to None.
-            **srs (string): spatial reference system of provided coordinates, with authority and code (same as the pyramid's one if not provided)
-
-        Raises:
-            Exception: Cannot find level to calculate indices
-            RuntimeError: Provided SRS is invalid for OSR
-
-        Examples:
-
-            FILE stored DTM (raster) pyramid, to get the altitude value at a point in the best level
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("/data/pyramids/RGEALTI.json")
-                    level, col, row, pcol, prow = pyramid.get_tile_indices(44, 5, srs = "EPSG:4326")
-                    data = pyramid.get_tile_data_raster(level, col, row)
-
-                    if data is None:
-                        print("No data")
-                    else:
-                        print(data[prow][pcol])
-
-                except Exception as e:
-                    print("Cannot get a pyramid's pixel value : {e}")
-
-        Returns:
-            Tuple[str, int, int, int, int]: Level identifier, tile's column, tile's row, pixel's (in the tile) column, pixel's row
-        """
-
-        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")
-
-        if (
-            "srs" in kwargs
-            and kwargs["srs"] is not None
-            and kwargs["srs"].upper() != self.__tms.srs.upper()
-        ):
-            sr = srs_to_spatialreference(kwargs["srs"])
-            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
-
-        Examples:
-
-                from rok4.pyramid import Pyramid
-
-                try:
-                    pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
-                    size = 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/pyramid.py b/src/rok4/pyramid.py
index 6c83f0e..8aa51aa 100644
--- a/src/rok4/pyramid.py
+++ b/src/rok4/pyramid.py
@@ -759,7 +759,9 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType, str, int, int], Dict]
                         'slab': 'DATA_18_5424_7526'
                     }
                 )
-
+        Raises:
+            StorageError: Unhandled pyramid storage to copy list
+            MissingEnvironmentError: Missing object storage informations
         """
         if self.__content["loaded"]:
             for slab, infos in self.__content["cache"].items():

From 965496af024ae28d73fb32792a6cf58cdb0589f3 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 10:58:32 +0200
Subject: [PATCH 67/89] Apply isort to existing codebase

---
 src/rok4/enums.py             |   3 +-
 src/rok4/layer.py             |   8 +--
 src/rok4/pyramid.py           |  32 +++++-----
 src/rok4/raster.py            |   7 +--
 src/rok4/storage.py           | 108 ++++++++++++++++----------------
 src/rok4/tile_matrix_set.py   |   5 +-
 src/rok4/utils.py             |   1 -
 src/rok4/vector.py            |   6 +-
 tests/test_layer.py           |   9 +--
 tests/test_pyramid.py         |  10 +--
 tests/test_raster.py          |   2 +-
 tests/test_storage.py         | 113 ++++++++++++++++++++++------------
 tests/test_tile_matrix_set.py |   9 +--
 tests/test_utils.py           |  15 +++--
 tests/test_vector.py          |   8 ++-
 15 files changed, 188 insertions(+), 148 deletions(-)

diff --git a/src/rok4/enums.py b/src/rok4/enums.py
index 861464f..8ca58ba 100644
--- a/src/rok4/enums.py
+++ b/src/rok4/enums.py
@@ -27,6 +27,7 @@ class StorageType(Enum):
     HTTPS = "https://"
     S3 = "s3://"
 
+
 class ColorFormat(Enum):
     """A color format enumeration.
     Except from "BIT", the member's name matches
@@ -36,4 +37,4 @@ class ColorFormat(Enum):
 
     BIT = 1
     UINT8 = 8
-    FLOAT32 = 32
\ No newline at end of file
+    FLOAT32 = 32
diff --git a/src/rok4/layer.py b/src/rok4/layer.py
index 631a870..6a72d0c 100644
--- a/src/rok4/layer.py
+++ b/src/rok4/layer.py
@@ -5,18 +5,18 @@
 - `Layer` - Descriptor to broadcast pyramids' data
 """
 
-from typing import Dict, List, Tuple, Union
 import json
-from json.decoder import JSONDecodeError
 import os
 import re
+from json.decoder import JSONDecodeError
+from typing import Dict, List, Tuple, Union
 
+from rok4.enums import PyramidType
 from rok4.exceptions import *
 from rok4.pyramid import Pyramid
-from rok4.tile_matrix_set import TileMatrixSet
 from rok4.storage import *
+from rok4.tile_matrix_set import TileMatrixSet
 from rok4.utils import *
-from rok4.enums import PyramidType
 
 
 class Layer:
diff --git a/src/rok4/pyramid.py b/src/rok4/pyramid.py
index ebb63b0..a2ae4a9 100644
--- a/src/rok4/pyramid.py
+++ b/src/rok4/pyramid.py
@@ -6,22 +6,23 @@
 - `Level` - Level of a pyramid
 """
 
-from typing import Dict, List, Tuple, Union, Iterator
+import io
 import json
-from json.decoder import JSONDecodeError
 import os
 import re
-import numpy
 import zlib
-import io
+from json.decoder import JSONDecodeError
+from typing import Dict, Iterator, List, Tuple, Union
+
 import mapbox_vector_tile
+import numpy
 from PIL import Image
 
+from rok4.enums import PyramidType, SlabType, StorageType
 from rok4.exceptions import *
-from rok4.tile_matrix_set import TileMatrixSet, TileMatrix
 from rok4.storage import *
+from rok4.tile_matrix_set import TileMatrix, TileMatrixSet
 from rok4.utils import *
-from rok4.enums import PyramidType, SlabType, StorageType
 
 ROK4_IMAGE_HEADER_SIZE = 2048
 """Slab's header size, 2048 bytes"""
@@ -535,11 +536,8 @@ def serializable(self) -> Dict:
         Returns:
             Dict: descriptor structured object description
         """
-        
-        serialization = {
-            "tile_matrix_set": self.__tms.name,
-            "format": self.__format
-        }
+
+        serialization = {"tile_matrix_set": self.__tms.name, "format": self.__format}
 
         serialization["levels"] = []
         sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
@@ -656,7 +654,6 @@ def format(self) -> str:
 
     @property
     def tile_extension(self) -> str:
-
         if self.__format in [
             "TIFF_RAW_UINT8",
             "TIFF_LZW_UINT8",
@@ -732,7 +729,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType, str, int, int], Dict]
             S3 stored descriptor
 
                 from rok4.pyramid import Pyramid
-                
+
                 try:
                     pyramid = Pyramid.from_descriptor("s3://bucket_name/path/to/descriptor.json")
 
@@ -756,7 +753,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType, str, int, int], Dict]
                         'slab': 'DATA_18_5424_7526'
                     }
                 )
-                
+
         Raises:
             StorageError: Unhandled pyramid storage to copy list
             MissingEnvironmentError: Missing object storage informations
@@ -774,7 +771,7 @@ def list_generator(self) -> Iterator[Tuple[Tuple[SlabType, str, int, int], Dict]
             roots = {}
             s3_cluster = self.storage_s3_cluster
 
-            with open(list_file, "r") as listin:
+            with open(list_file) as listin:
                 # Lecture des racines
                 for line in listin:
                     line = line.rstrip()
@@ -1170,7 +1167,6 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
         level_object = self.get_level(level)
 
         if self.__format == "TIFF_JPG_UINT8" or self.__format == "TIFF_JPG90_UINT8":
-
             try:
                 img = Image.open(io.BytesIO(binary_tile))
             except Exception as e:
@@ -1368,10 +1364,10 @@ def size(self) -> int:
         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/raster.py b/src/rok4/raster.py
index 95ccf68..3d2d813 100644
--- a/src/rok4/raster.py
+++ b/src/rok4/raster.py
@@ -9,14 +9,13 @@
 import copy
 import json
 import re
-
 from typing import Dict, Tuple
 
 from osgeo import gdal, ogr
 
+from rok4.enums import ColorFormat
 from rok4.storage import exists, get_osgeo_path, put_data_str
 from rok4.utils import compute_bbox, compute_format
-from rok4.enums import ColorFormat
 
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
@@ -239,7 +238,7 @@ def from_list(cls, path: str, srs: str) -> "RasterSet":
 
         local_list_path = get_osgeo_path(path)
         image_list = []
-        with open(file=local_list_path, mode="r") as list_file:
+        with open(file=local_list_path) as list_file:
             for line in list_file:
                 image_path = line.strip(" \t\n\r")
                 image_list.append(image_path)
@@ -298,7 +297,7 @@ def from_descriptor(cls, path: str) -> "RasterSet":
         """
         self = cls()
         descriptor_path = get_osgeo_path(path)
-        with open(file=descriptor_path, mode="r") as file_handle:
+        with open(file=descriptor_path) as file_handle:
             raw_content = file_handle.read()
         serialization = json.loads(raw_content)
         self.srs = serialization["srs"]
diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index 6e2eca8..f0a5ffa 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -30,23 +30,23 @@
 To precise the cluster to use, bucket name should be bucket_name@s3.storage.fr or bucket_name@s4.storage.fr. If no host is defined (no @) in the bucket name, first S3 cluster is used
 """
 
+import hashlib
+import os
+import re
+import tempfile
+from shutil import copyfile
+from typing import Dict, List, Tuple, Union
+
 import boto3
 import botocore.exceptions
-import tempfile
-import re
-import os
 import rados
-import hashlib
 import requests
-from typing import Dict, List, Tuple, Union
-from shutil import copyfile
 from osgeo import gdal
 
 gdal.UseExceptions()
 
-from rok4.exceptions import *
 from rok4.enums import StorageType
-
+from rok4.exceptions import *
 
 __S3_CLIENTS = {}
 __S3_DEFAULT_CLIENT = None
@@ -355,16 +355,15 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
-        if range is None :
+        if range is None:
             try:
                 reponse = requests.get(f"{storage_type.value}{path}", stream=True)
                 data = reponse.content
-                if reponse.status_code == 404 :
+                if reponse.status_code == 404:
                     raise FileNotFoundError(f"{storage_type.value}{path}")
             except Exception as e:
                 raise StorageError(storage_type.name, e)
-        else :
+        else:
             raise NotImplementedError
 
     else:
@@ -463,7 +462,6 @@ def get_size(path: str) -> int:
             raise StorageError("FILE", e)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
         try:
             # Le stream=True permet de ne télécharger que le header initialement
             reponse = requests.get(storage_type.value + path, stream=True).headers["content-length"]
@@ -518,12 +516,11 @@ def exists(path: str) -> bool:
         return os.path.exists(path)
 
     elif storage_type == StorageType.HTTP or storage_type == StorageType.HTTPS:
-
         try:
             response = requests.get(storage_type.value + path, stream=True)
-            if response.status_code == 200 :
+            if response.status_code == 200:
                 return True
-            else :
+            else:
                 return False
         except Exception as e:
             raise StorageError(storage_type.name, e)
@@ -831,47 +828,52 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}"
             )
 
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.FILE :
-
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.FILE:
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream=True)
             with open(to_path, "wb") as f:
-                for chunk in response.iter_content(chunk_size=65536) :
-
+                for chunk in response.iter_content(chunk_size=65536):
                     if chunk:
                         f.write(chunk)
 
         except Exception as e:
+            raise StorageError(
+                f"HTTP(S) and FILE",
+                f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}",
+            )
 
-            raise StorageError(f"HTTP(S) and FILE", f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}")
-
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.CEPH :
-
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.CEPH:
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
+            response = requests.get(from_type.value + from_path, stream=True)
             offset = 0
-            for chunk in response.iter_content(chunk_size=65536) :
+            for chunk in response.iter_content(chunk_size=65536):
                 if chunk:
                     size = len(chunk)
                     to_ioctx.write(to_base_name, chunk, offset)
                     offset += size
 
         except Exception as e:
+            raise StorageError(
+                f"HTTP(S) and CEPH",
+                f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}",
+            )
 
-            raise StorageError(f"HTTP(S) and CEPH", f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}")
-
-    elif (from_type == StorageType.HTTP or from_type == StorageType.HTTPS) and to_type == StorageType.S3 :
-
+    elif (
+        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
+    ) and to_type == StorageType.S3:
         to_s3_client, to_bucket = __get_s3_client(to_tray)
 
         try:
-            response = requests.get(from_type.value + from_path, stream = True)
-            with tempfile.NamedTemporaryFile("w+b",delete=False) as f:
+            response = requests.get(from_type.value + from_path, stream=True)
+            with tempfile.NamedTemporaryFile("w+b", delete=False) as f:
                 name_fich = f.name
-                for chunk in response.iter_content(chunk_size=65536) :
-
+                for chunk in response.iter_content(chunk_size=65536):
                     if chunk:
                         f.write(chunk)
 
@@ -880,8 +882,10 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             os.remove(name_fich)
 
         except Exception as e:
-            raise StorageError(f"HTTP(S) and S3", f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}")
-
+            raise StorageError(
+                f"HTTP(S) and S3",
+                f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}",
+            )
 
     else:
         raise StorageError(
@@ -928,9 +932,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
 
         try:
             target_s3_client["client"].put_object(
-                Body=f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode(
-                    "utf-8"
-                ),
+                Body=f"{__OBJECT_SYMLINK_SIGNATURE}{target_bucket}/{target_base_name}".encode(),
                 Bucket=link_bucket,
                 Key=link_base_name,
             )
@@ -941,9 +943,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
         ioctx = __get_ceph_ioctx(link_tray)
 
         try:
-            ioctx.write_full(
-                link_base_name, f"{__OBJECT_SYMLINK_SIGNATURE}{target_path}".encode("utf-8")
-            )
+            ioctx.write_full(link_base_name, f"{__OBJECT_SYMLINK_SIGNATURE}{target_path}".encode())
         except Exception as e:
             raise StorageError("CEPH", e)
 
@@ -995,7 +995,8 @@ 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 :
+
+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:
@@ -1008,10 +1009,10 @@ def size_path(path: str) -> int :
     Returns:
         int: size of the path
     """
-    storage_type, unprefixed_path, tray_name, base_name  = get_infos_from_path(path)
+    storage_type, unprefixed_path, tray_name, base_name = get_infos_from_path(path)
 
     if storage_type == StorageType.FILE:
-        try :
+        try:
             total = 0
             with os.scandir(unprefixed_path) as it:
                 for entry in it:
@@ -1026,20 +1027,19 @@ def size_path(path: str) -> int :
     elif storage_type == StorageType.S3:
         s3_client, bucket_name = __get_s3_client(tray_name)
 
-
-        try :
-            paginator = s3_client["client"].get_paginator('list_objects_v2')
+        try:
+            paginator = s3_client["client"].get_paginator("list_objects_v2")
             pages = paginator.paginate(
                 Bucket=bucket_name,
-                Prefix=base_name+"/",
+                Prefix=base_name + "/",
                 PaginationConfig={
-                    'PageSize': 10000,
-                }
+                    "PageSize": 10000,
+                },
             )
             total = 0
             for page in pages:
-                for key in page['Contents']:
-                    total += key['Size']
+                for key in page["Contents"]:
+                    total += key["Size"]
 
         except Exception as e:
             raise StorageError("S3", e)
diff --git a/src/rok4/tile_matrix_set.py b/src/rok4/tile_matrix_set.py
index b6685bd..976a63e 100644
--- a/src/rok4/tile_matrix_set.py
+++ b/src/rok4/tile_matrix_set.py
@@ -9,15 +9,16 @@
 - ROK4_TMS_DIRECTORY
 """
 
-from typing import Dict, List, Tuple
-from json.decoder import JSONDecodeError
 import json
 import os
+from json.decoder import JSONDecodeError
+from typing import Dict, List, Tuple
 
 from rok4.exceptions import *
 from rok4.storage import get_data_str
 from rok4.utils import *
 
+
 class TileMatrix:
     """A tile matrix is a tile matrix set's level.
 
diff --git a/src/rok4/utils.py b/src/rok4/utils.py
index 4db30d4..004852b 100644
--- a/src/rok4/utils.py
+++ b/src/rok4/utils.py
@@ -3,7 +3,6 @@
 
 import os
 import re
-
 from typing import Dict, List, Tuple, Union
 
 from osgeo import gdal, ogr, osr
diff --git a/src/rok4/vector.py b/src/rok4/vector.py
index c3c045b..2cdb0a2 100644
--- a/src/rok4/vector.py
+++ b/src/rok4/vector.py
@@ -6,15 +6,17 @@
 
 """
 
-from osgeo import ogr
 import os
 import tempfile
 
+from osgeo import ogr
+
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
-from rok4.storage import get_osgeo_path, copy
 from rok4.exceptions import *
+from rok4.storage import copy, get_osgeo_path
+
 
 class Vector:
     """A data vector
diff --git a/tests/test_layer.py b/tests/test_layer.py
index a9a79a2..9cd314b 100644
--- a/tests/test_layer.py
+++ b/tests/test_layer.py
@@ -1,12 +1,13 @@
-import pytest
 import os
-
-from unittest.mock import *
 from unittest import mock
+from unittest.mock import *
+
+import pytest
 
-from rok4.layer import Layer
 from rok4.enums import PyramidType
 from rok4.exceptions import *
+from rok4.layer import Layer
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch(
diff --git a/tests/test_pyramid.py b/tests/test_pyramid.py
index fa04a01..e71dd15 100644
--- a/tests/test_pyramid.py
+++ b/tests/test_pyramid.py
@@ -1,13 +1,15 @@
-import pytest
 import os
-from unittest.mock import *
 from unittest import mock
+from unittest.mock import *
+
+import pytest
 
+from rok4.enums import SlabType, StorageType
+from rok4.exceptions import *
 from rok4.pyramid import *
 from rok4.tile_matrix_set import TileMatrixSet
-from rok4.enums import SlabType, StorageType
 from rok4.utils import *
-from rok4.exceptions import *
+
 
 @mock.patch("rok4.pyramid.get_data_str", side_effect=StorageError("FILE", "Not found"))
 def test_wrong_file(mocked_get_data_str):
diff --git a/tests/test_raster.py b/tests/test_raster.py
index c91f527..8bf80f0 100644
--- a/tests/test_raster.py
+++ b/tests/test_raster.py
@@ -14,8 +14,8 @@
 
 import pytest
 
-from rok4.raster import Raster, RasterSet
 from rok4.enums import ColorFormat
+from rok4.raster import Raster, RasterSet
 
 # rok4.raster.Raster class tests
 
diff --git a/tests/test_storage.py b/tests/test_storage.py
index d60e8c0..f2649e5 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -1,15 +1,15 @@
-import pytest
 import os
+from unittest import mock
+from unittest.mock import *
 
 import botocore.exceptions
+import pytest
 from rados import ObjectNotFound
 
-from unittest import mock
-from unittest.mock import *
-
-from rok4.storage import *
-from rok4.exceptions import *
 from rok4.enums import StorageType
+from rok4.exceptions import *
+from rok4.storage import *
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @patch("builtins.open", new_callable=mock_open, read_data=b"data")
@@ -21,6 +21,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)
 def test_get_infos_from_path():
     assert (StorageType.S3, "toto/titi", "toto", "titi") == get_infos_from_path("s3://toto/titi")
@@ -118,6 +119,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"},
@@ -160,8 +162,9 @@ def test_ceph_read_ok(mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH read raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch("requests.get", side_effect={"status_code":404})
+@mock.patch("requests.get", side_effect={"status_code": 404})
 def test_http_read_error(mock_http):
     with pytest.raises(StorageError):
         requests_instance = MagicMock()
@@ -172,18 +175,19 @@ def test_http_read_error(mock_http):
 
     mock_http.assert_called_with("http://path/to/file.ext", stream=True)
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_http_read_range_error():
     with pytest.raises(NotImplementedError):
-        data = get_data_binary("http://path/to/file.ext", (0,100))
+        data = get_data_binary("http://path/to/file.ext", (0, 100))
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("requests.get")
 def test_http_read_ok(mock_http):
-
-    try :
+    try:
         requests_instance = MagicMock()
-        requests_instance.content = b'data'
+        requests_instance.content = b"data"
         mock_http.return_value = requests_instance
 
         data = get_data_str("http://path/to/file.ext")
@@ -195,6 +199,7 @@ def test_http_read_ok(mock_http):
 
 ############ 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"},
@@ -227,6 +232,7 @@ def test_s3_write_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -304,6 +310,7 @@ def test_copy_s3_file_nok(mock_hash_file, mock_makedirs, mocked_s3_client):
         copy("s3://bucket/source.ext", "file:///path/to/destination.ext", "toto")
         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"},
@@ -322,6 +329,7 @@ def test_copy_file_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -340,6 +348,7 @@ def test_copy_s3_s3_ok(mocked_s3_client):
     except Exception as exc:
         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"},
@@ -402,6 +411,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"},
@@ -491,14 +501,14 @@ def test_copy_ceph_s3_ok(mock_file, mocked_s3_client, mocked_rados_client):
     except Exception as exc:
         assert False, f"CEPH -> S3 copy raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
-@patch('builtins.open', new_callable=mock_open)
+@mock.patch("requests.get")
+@patch("builtins.open", new_callable=mock_open)
 def test_copy_http_file_ok(mock_open, mock_requests):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         copy("http://path/to/source.ext", "file:///path/to/destination.ext")
@@ -507,14 +517,18 @@ def test_copy_http_file_ok(mock_open, mock_requests):
     except Exception as exc:
         assert False, f"HTTP -> 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('rok4.storage.rados.Rados')
-@mock.patch('requests.get')
+
+@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("requests.get")
 def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         disconnect_ceph_clients()
@@ -529,16 +543,20 @@ def test_copy_http_ceph_ok(mock_requests, mocked_rados_client):
     except Exception as exc:
         assert False, f"HTTP -> CEPH 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('rok4.storage.boto3.client')
-@mock.patch('requests.get')
-@patch('tempfile.NamedTemporaryFile', new_callable=mock_open)
-@mock.patch('os.remove')
+
+@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("requests.get")
+@patch("tempfile.NamedTemporaryFile", new_callable=mock_open)
+@mock.patch("os.remove")
 def test_copy_http_s3_ok(mock_remove, mock_tempfile, mock_requests, mocked_s3_client):
     try:
-
         http_instance = MagicMock()
-        http_instance.iter_content.return_value = ["data","data2"]
+        http_instance.iter_content.return_value = ["data", "data2"]
         mock_requests.return_value = http_instance
 
         disconnect_s3_clients()
@@ -586,6 +604,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"},
@@ -642,6 +661,7 @@ def test_link_s3_nok(mocked_s3_client):
 
 ############ get_size
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("os.stat")
 def test_size_file_ok(mock_stat):
@@ -652,6 +672,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"},
@@ -672,6 +693,7 @@ def test_size_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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"},
@@ -690,12 +712,12 @@ def test_size_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"S3 size raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_size_http_ok(mock_requests):
-
     http_instance = MagicMock()
-    http_instance.headers = {"content-length":12}
+    http_instance.headers = {"content-length": 12}
     mock_requests.return_value = http_instance
 
     try:
@@ -722,6 +744,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"},
@@ -773,10 +796,10 @@ def test_exists_s3_ok(mocked_s3_client):
     except Exception as exc:
         assert False, f"CEPH not exists raises an exception: {exc}"
 
+
 @mock.patch.dict(os.environ, {}, clear=True)
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_exists_http_ok(mock_requests):
-
     http_instance = MagicMock()
     http_instance.status_code = 200
     mock_requests.return_value = http_instance
@@ -839,6 +862,7 @@ def test_remove_ceph_ok(mocked_rados_client):
     except Exception as exc:
         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"},
@@ -868,6 +892,7 @@ 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"},
@@ -888,6 +913,7 @@ def test_get_osgeo_path_nok():
     with pytest.raises(NotImplementedError):
         get_osgeo_path("ceph://pool/data.ext")
 
+
 ############ size_path
 def test_size_path_file_ok():
     try:
@@ -898,21 +924,29 @@ def test_size_path_file_ok():
 
 
 def test_size_file_nok():
-    with pytest.raises(StorageError) :
+    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)
-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,
+)
+def test_size_path_ceph_nok():
     with pytest.raises(NotImplementedError):
         size = size_path("ceph://pool/path")
 
-@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):
 
+@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}]}]
+    pages = [{"Contents": [{"Size": 10}, {"Size": 20}]}, {"Contents": [{"Size": 50}]}]
     paginator = MagicMock()
     paginator.paginate.return_value = pages
     client = MagicMock()
@@ -924,4 +958,3 @@ def test_size_path_s3_ok(mocked_s3_client):
         assert size == 80
     except Exception as exc:
         assert False, f"S3 size of the path raises an exception: {exc}"
-
diff --git a/tests/test_tile_matrix_set.py b/tests/test_tile_matrix_set.py
index 98bccd6..faf03f1 100644
--- a/tests/test_tile_matrix_set.py
+++ b/tests/test_tile_matrix_set.py
@@ -1,11 +1,12 @@
-
-import pytest
 import os
-from unittest.mock import *
 from unittest import mock
+from unittest.mock import *
+
+import pytest
 
-from rok4.tile_matrix_set import TileMatrixSet
 from rok4.exceptions import *
+from rok4.tile_matrix_set import TileMatrixSet
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_missing_env():
diff --git a/tests/test_utils.py b/tests/test_utils.py
index bfcb636..0b73b9e 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,14 +1,15 @@
-import pytest
-import os
-from osgeo import gdal, osr
 import math
+import os
 import random
-
-from unittest.mock import *
 from unittest import mock
+from unittest.mock import *
+
+import pytest
+from osgeo import gdal, osr
 
-from rok4.utils import *
 from rok4.exceptions import *
+from rok4.utils import *
+
 
 def test_srs_to_spatialreference_ignf_ok():
     try:
@@ -75,6 +76,7 @@ def test_reproject_point_ok():
 
 # Tests for the rok4.utils.compute_bbox function.
 
+
 def test_compute_bbox_epsg_3857_ok():
     try:
         mocked_datasource = MagicMock(gdal.Dataset)
@@ -215,6 +217,7 @@ def test_compute_bbox_no_srs_ok():
 
 # Tests for the rok4.utils.compute_format function.
 
+
 @mock.patch("rok4.utils.gdal.Info")
 @mock.patch("rok4.utils.gdal.GetColorInterpretationName", return_value="Palette")
 @mock.patch("rok4.utils.gdal.GetDataTypeSize", return_value=8)
diff --git a/tests/test_vector.py b/tests/test_vector.py
index 513c559..8f75618 100644
--- a/tests/test_vector.py
+++ b/tests/test_vector.py
@@ -1,11 +1,13 @@
-import pytest
 import os
-from unittest.mock import *
 from unittest import mock
+from unittest.mock import *
+
+import pytest
 
-from rok4.vector import *
 from rok4.exceptions import *
 from rok4.storage import disconnect_ceph_clients
+from rok4.vector import *
+
 
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_missing_env():

From 3a33229bb9811c11993640809ed53262a4b47a91 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 14:06:00 +0200
Subject: [PATCH 68/89] Add dependabot configuration

---
 .github/dependabot.yml | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 .github/dependabot.yml

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..9327b14
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,19 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: "/"
+    schedule:
+      interval: monthly
+      time: "17:00"
+      timezone: Europe/Paris
+    labels:
+      - dependencies
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: monthly
+      time: "22:00"
+      timezone: Europe/Paris
+    labels:
+      - ci-cd

From 31e3fce7e50d4851c497cf1f1ac96771ed4c3483 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 14:37:32 +0200
Subject: [PATCH 69/89] Add requests as 3rd party dependency

---
 pyproject.toml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index f172c36..29e103b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -32,9 +32,10 @@ classifiers = [
 
 dependencies = [
   "boto3 >= 1.26.54",
-  "pillow >= 9.4.0",
+  "mapbox-vector-tile >= 2.0.1",
   "numpy >= 1.24.2",
-  "mapbox-vector-tile >= 2.0.1"
+  "pillow >= 9.4.0",
+  "requests >= 2.31.0"
 ]
 
 [project.optional-dependencies]

From f9d0b3897397492d77c147f246a6cc738ee334f4 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 14:39:12 +0200
Subject: [PATCH 70/89] Decrease requests min version

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 29e103b..029bfdf 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,7 +35,7 @@ dependencies = [
   "mapbox-vector-tile >= 2.0.1",
   "numpy >= 1.24.2",
   "pillow >= 9.4.0",
-  "requests >= 2.31.0"
+  "requests >= 2.30.0"
 ]
 
 [project.optional-dependencies]

From 66a706559989d13f623748ae5fa77b4046c5e8e3 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 17:30:45 +0200
Subject: [PATCH 71/89] Fix some of minor issues spotted by linters

---
 src/rok4/layer.py           | 27 ++++++++-------
 src/rok4/pyramid.py         | 41 +++++++++++++++--------
 src/rok4/raster.py          |  7 ++++
 src/rok4/storage.py         | 65 ++++++++++++++++++++-----------------
 src/rok4/tile_matrix_set.py | 16 ++++++---
 src/rok4/utils.py           | 13 +++++---
 src/rok4/vector.py          | 16 ++++++---
 7 files changed, 116 insertions(+), 69 deletions(-)

diff --git a/src/rok4/layer.py b/src/rok4/layer.py
index 6a72d0c..dfccac9 100644
--- a/src/rok4/layer.py
+++ b/src/rok4/layer.py
@@ -5,18 +5,21 @@
 - `Layer` - Descriptor to broadcast pyramids' data
 """
 
+# -- IMPORTS --
+
+# standard library
 import json
 import os
 import re
 from json.decoder import JSONDecodeError
-from typing import Dict, List, Tuple, Union
+from typing import Dict, List, Tuple
 
+# package
 from rok4.enums import PyramidType
-from rok4.exceptions import *
+from rok4.exceptions import FormatError, MissingAttributeError
 from rok4.pyramid import Pyramid
-from rok4.storage import *
-from rok4.tile_matrix_set import TileMatrixSet
-from rok4.utils import *
+from rok4.storage import get_data_str, get_infos_from_path, put_data_str
+from rok4.utils import reproject_bbox
 
 
 class Layer:
@@ -92,8 +95,8 @@ def from_descriptor(cls, descriptor: str) -> "Layer":
                 )
                 layer.__bbox = reproject_bbox(layer.__geobbox, "EPSG:4326", layer.__tms.srs, 5)
                 # On force l'emprise de la couche, on recalcule donc les tuiles limites correspondantes pour chaque niveau
-                for l in layer.__levels.values():
-                    l.set_limits_from_bbox(layer.__bbox)
+                for level in layer.__levels.values():
+                    level.set_limits_from_bbox(layer.__bbox)
             else:
                 layer.__bbox = layer.__best_level.bbox
                 layer.__geobbox = reproject_bbox(layer.__bbox, layer.__tms.srs, "EPSG:4326", 5)
@@ -184,7 +187,7 @@ def __load_pyramids(self, pyramids: List[Dict[str, str]]) -> None:
             Exception: Overlapping in usage pyramids' levels
         """
 
-        ## Toutes les pyramides doivent avoir les même caractéristiques
+        # Toutes les pyramides doivent avoir les même caractéristiques
         channels = None
         for p in pyramids:
             pyramid = Pyramid.from_descriptor(p["path"])
@@ -221,10 +224,10 @@ def __load_pyramids(self, pyramids: List[Dict[str, str]]) -> None:
                 self.__resampling = pyramid.raster_specifications["interpolation"]
 
             levels = pyramid.get_levels(bottom_level, top_level)
-            for l in levels:
-                if l.id in self.__levels:
-                    raise Exception(f"Level {l.id} is present in two used pyramids")
-                self.__levels[l.id] = l
+            for level in levels:
+                if level.id in self.__levels:
+                    raise Exception(f"Level {level.id} is present in two used pyramids")
+                self.__levels[level.id] = level
 
             self.__pyramids.append(
                 {"pyramid": pyramid, "bottom_level": bottom_level, "top_level": top_level}
diff --git a/src/rok4/pyramid.py b/src/rok4/pyramid.py
index a2ae4a9..7566e93 100644
--- a/src/rok4/pyramid.py
+++ b/src/rok4/pyramid.py
@@ -6,24 +6,37 @@
 - `Level` - Level of a pyramid
 """
 
+# -- IMPORTS --
+
+# standard library
 import io
 import json
 import os
 import re
+import tempfile
 import zlib
 from json.decoder import JSONDecodeError
-from typing import Dict, Iterator, List, Tuple, Union
+from typing import Dict, Iterator, List, Tuple
 
+# 3rd party
 import mapbox_vector_tile
 import numpy
 from PIL import Image
 
+# package
 from rok4.enums import PyramidType, SlabType, StorageType
-from rok4.exceptions import *
-from rok4.storage import *
+from rok4.exceptions import FormatError, MissingAttributeError
+from rok4.storage import (
+    copy,
+    get_data_str,
+    get_infos_from_path,
+    get_path_from_infos,
+    put_data_str,
+    remove,
+)
 from rok4.tile_matrix_set import TileMatrix, TileMatrixSet
-from rok4.utils import *
 
+# -- GLOBALS --
 ROK4_IMAGE_HEADER_SIZE = 2048
 """Slab's header size, 2048 bytes"""
 
@@ -441,8 +454,8 @@ def from_descriptor(cls, descriptor: str) -> "Pyramid":
                     pyramid.__masks = False
 
             # Niveaux
-            for l in data["levels"]:
-                lev = Level.from_descriptor(l, pyramid)
+            for level in data["levels"]:
+                lev = Level.from_descriptor(level, pyramid)
                 pyramid.__levels[lev.id] = lev
 
                 if pyramid.__tms.get_level(lev.id) is None:
@@ -510,8 +523,8 @@ def from_other(cls, other: "Pyramid", name: str, storage: Dict) -> "Pyramid":
                 pyramid.__raster_specifications = other.__raster_specifications
 
             # Niveaux
-            for l in other.__levels.values():
-                lev = Level.from_other(l, pyramid)
+            for level in other.__levels.values():
+                lev = Level.from_other(level, pyramid)
                 pyramid.__levels[lev.id] = lev
 
         except KeyError as e:
@@ -542,8 +555,8 @@ def serializable(self) -> Dict:
         serialization["levels"] = []
         sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
 
-        for l in sorted_levels:
-            serialization["levels"].append(l.serializable)
+        for level in sorted_levels:
+            serialization["levels"].append(level.serializable)
 
         if self.type == PyramidType.RASTER:
             serialization["raster_specifications"] = self.__raster_specifications
@@ -1059,7 +1072,7 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
             raise Exception(f"No level {level} in the pyramid")
 
         if level_object.slab_width == 1 and level_object.slab_height == 1:
-            raise NotImplementedError(f"One-tile slab pyramid is not handled")
+            raise NotImplementedError("One-tile slab pyramid is not handled")
 
         if not level_object.is_in_limits(column, row):
             return None
@@ -1090,7 +1103,7 @@ def get_tile_data_binary(self, level: str, column: int, row: int) -> str:
                     2 * 4 * level_object.slab_width * level_object.slab_height,
                 ),
             )
-        except FileNotFoundError as e:
+        except FileNotFoundError:
             # L'absence de la dalle est gérée comme simplement une absence de données
             return None
 
@@ -1277,7 +1290,7 @@ def get_tile_data_vector(self, level: str, column: int, row: int) -> Dict:
         if binary_tile is None:
             return None
 
-        level_object = self.get_level(level)
+        self.get_level(level)
 
         if self.__format == "TIFF_PBF_MVT":
             try:
@@ -1334,7 +1347,7 @@ def get_tile_indices(
             level_object = self.get_level(level)
 
         if level_object is None:
-            raise Exception(f"Cannot found the level to calculate indices")
+            raise Exception("Cannot found the level to calculate indices")
 
         if (
             "srs" in kwargs
diff --git a/src/rok4/raster.py b/src/rok4/raster.py
index 3d2d813..d52617e 100644
--- a/src/rok4/raster.py
+++ b/src/rok4/raster.py
@@ -6,17 +6,24 @@
     - RasterSet - Structure describing a set of raster data.
 """
 
+# -- IMPORTS --
+
+# standard library
 import copy
 import json
 import re
 from typing import Dict, Tuple
 
+# 3rd party
 from osgeo import gdal, ogr
 
+# package
 from rok4.enums import ColorFormat
 from rok4.storage import exists, get_osgeo_path, put_data_str
 from rok4.utils import compute_bbox, compute_format
 
+# -- GLOBALS --
+
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 gdal.UseExceptions()
diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index f0a5ffa..3b17bea 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -30,24 +30,31 @@
 To precise the cluster to use, bucket name should be bucket_name@s3.storage.fr or bucket_name@s4.storage.fr. If no host is defined (no @) in the bucket name, first S3 cluster is used
 """
 
+# -- IMPORTS --
+
+# standard library
 import hashlib
 import os
 import re
 import tempfile
 from shutil import copyfile
-from typing import Dict, List, Tuple, Union
+from typing import Dict, Tuple, Union
 
+# 3rd party
 import boto3
 import botocore.exceptions
 import rados
 import requests
 from osgeo import gdal
 
-gdal.UseExceptions()
-
+# package
 from rok4.enums import StorageType
-from rok4.exceptions import *
+from rok4.exceptions import MissingEnvironmentError, StorageError
 
+# -- GLOBALS --
+
+# Enable GDAL/OGR exceptions
+gdal.UseExceptions()
 __S3_CLIENTS = {}
 __S3_DEFAULT_CLIENT = None
 
@@ -331,7 +338,7 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             else:
                 data = ioctx.read(base_name, range[1], range[0])
 
-        except rados.ObjectNotFound as e:
+        except rados.ObjectNotFound:
             raise FileNotFoundError(f"{storage_type.value}{path}")
 
         except Exception as e:
@@ -348,7 +355,7 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
 
             f.close()
 
-        except FileNotFoundError as e:
+        except FileNotFoundError:
             raise FileNotFoundError(f"{storage_type.value}{path}")
 
         except Exception as e:
@@ -507,7 +514,7 @@ def exists(path: str) -> bool:
         try:
             ioctx.stat(base_name)
             return True
-        except rados.ObjectNotFound as e:
+        except rados.ObjectNotFound:
             return False
         except Exception as e:
             raise StorageError("CEPH", e)
@@ -554,7 +561,7 @@ def remove(path: str) -> None:
 
         try:
             ioctx.remove_object(base_name)
-        except rados.ObjectNotFound as e:
+        except rados.ObjectNotFound:
             pass
         except Exception as e:
             raise StorageError("CEPH", e)
@@ -562,7 +569,7 @@ def remove(path: str) -> None:
     elif storage_type == StorageType.FILE:
         try:
             os.remove(path)
-        except FileNotFoundError as e:
+        except FileNotFoundError:
             pass
         except Exception as e:
             raise StorageError("FILE", e)
@@ -599,12 +606,12 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 to_md5 = hash_file(to_path)
                 if to_md5 != from_md5:
                     raise StorageError(
-                        f"FILE",
+                        "FILE",
                         f"Invalid MD5 sum control for copy file {from_path} to {to_path} : {from_md5} != {to_md5}",
                     )
 
         except Exception as e:
-            raise StorageError(f"FILE", f"Cannot copy file {from_path} to {to_path} : {e}")
+            raise StorageError("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)
@@ -625,7 +632,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
         except Exception as e:
             raise StorageError(
-                f"S3 and FILE", f"Cannot copy S3 object {from_path} to file {to_path} : {e}"
+                "S3 and FILE", f"Cannot copy S3 object {from_path} to file {to_path} : {e}"
             )
 
     elif from_type == StorageType.FILE and to_type == StorageType.S3:
@@ -642,12 +649,12 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 )
                 if to_md5 != from_md5:
                     raise StorageError(
-                        f"FILE and S3",
+                        "FILE and S3",
                         f"Invalid MD5 sum control for copy file {from_path} to S3 object {to_path} : {from_md5} != {to_md5}",
                     )
         except Exception as e:
             raise StorageError(
-                f"FILE and S3", f"Cannot copy file {from_path} to S3 object {to_path} : {e}"
+                "FILE and S3", f"Cannot copy file {from_path} to S3 object {to_path} : {e}"
             )
 
     elif from_type == StorageType.S3 and to_type == StorageType.S3:
@@ -672,12 +679,12 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 )
                 if to_md5 != from_md5:
                     raise StorageError(
-                        f"S3",
+                        "S3",
                         f"Invalid MD5 sum control for copy S3 object {from_path} to {to_path} : {from_md5} != {to_md5}",
                     )
 
         except Exception as e:
-            raise StorageError(f"S3", f"Cannot copy S3 object {from_path} to {to_path} : {e}")
+            raise StorageError("S3", f"Cannot copy S3 object {from_path} to {to_path} : {e}")
 
     elif from_type == StorageType.CEPH and to_type == StorageType.FILE:
         ioctx = __get_ceph_ioctx(from_tray)
@@ -709,13 +716,13 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
                 raise StorageError(
-                    f"CEPH and FILE",
+                    "CEPH and FILE",
                     f"Invalid MD5 sum control for copy CEPH object {from_path} to file {to_path} : {from_md5} != {checker.hexdigest()}",
                 )
 
         except Exception as e:
             raise StorageError(
-                f"CEPH and FILE", f"Cannot copy CEPH object {from_path} to file {to_path} : {e}"
+                "CEPH and FILE", f"Cannot copy CEPH object {from_path} to file {to_path} : {e}"
             )
 
     elif from_type == StorageType.FILE and to_type == StorageType.CEPH:
@@ -746,13 +753,13 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
                 raise StorageError(
-                    f"FILE and CEPH",
+                    "FILE and CEPH",
                     f"Invalid MD5 sum control for copy file {from_path} to CEPH object {to_path} : {from_md5} != {checker.hexdigest()}",
                 )
 
         except Exception as e:
             raise StorageError(
-                f"FILE and CEPH", f"Cannot copy file {from_path} to CEPH object {to_path} : {e}"
+                "FILE and CEPH", f"Cannot copy file {from_path} to CEPH object {to_path} : {e}"
             )
 
     elif from_type == StorageType.CEPH and to_type == StorageType.CEPH:
@@ -780,12 +787,12 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
                 raise StorageError(
-                    f"FILE and CEPH",
+                    "FILE and CEPH",
                     f"Invalid MD5 sum control for copy CEPH object {from_path} to {to_path} : {from_md5} != {checker.hexdigest()}",
                 )
 
         except Exception as e:
-            raise StorageError(f"CEPH", f"Cannot copy CEPH object {from_path} to {to_path} : {e}")
+            raise StorageError("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)
@@ -819,13 +826,13 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
             if from_md5 is not None and from_md5 != checker.hexdigest():
                 raise StorageError(
-                    f"CEPH and S3",
+                    "CEPH and S3",
                     f"Invalid MD5 sum control for copy CEPH object {from_path} to S3 object {to_path} : {from_md5} != {checker.hexdigest()}",
                 )
 
         except Exception as e:
             raise StorageError(
-                f"CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}"
+                "CEPH and S3", f"Cannot copy CEPH object {from_path} to S3 object {to_path} : {e}"
             )
 
     elif (
@@ -840,7 +847,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
         except Exception as e:
             raise StorageError(
-                f"HTTP(S) and FILE",
+                "HTTP(S) and FILE",
                 f"Cannot copy HTTP(S) object {from_path} to FILE object {to_path} : {e}",
             )
 
@@ -860,7 +867,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
         except Exception as e:
             raise StorageError(
-                f"HTTP(S) and CEPH",
+                "HTTP(S) and CEPH",
                 f"Cannot copy HTTP(S) object {from_path} to CEPH object {to_path} : {e}",
             )
 
@@ -883,7 +890,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
         except Exception as e:
             raise StorageError(
-                f"HTTP(S) and S3",
+                "HTTP(S) and S3",
                 f"Cannot copy HTTP(S) object {from_path} to S3 object {to_path} : {e}",
             )
 
@@ -913,7 +920,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
     if target_type != link_type:
         raise StorageError(
             f"{target_type.name} and {link_type.name}",
-            f"Cannot make link between two different storage types",
+            "Cannot make link between two different storage types",
         )
 
     if hard and target_type != StorageType.FILE:
@@ -926,7 +933,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
 
         if target_s3_client["host"] != link_s3_client["host"]:
             raise StorageError(
-                f"S3",
+                "S3",
                 f"Cannot make link {link_path} -> {target_path} : link works only on the same S3 cluster",
             )
 
diff --git a/src/rok4/tile_matrix_set.py b/src/rok4/tile_matrix_set.py
index 976a63e..14bae9f 100644
--- a/src/rok4/tile_matrix_set.py
+++ b/src/rok4/tile_matrix_set.py
@@ -9,14 +9,20 @@
 - ROK4_TMS_DIRECTORY
 """
 
+# -- IMPORTS --
+
+# standard library
 import json
 import os
 from json.decoder import JSONDecodeError
 from typing import Dict, List, Tuple
 
-from rok4.exceptions import *
+# package
+from rok4.exceptions import FormatError, MissingAttributeError, MissingEnvironmentError
 from rok4.storage import get_data_str
-from rok4.utils import *
+from rok4.utils import srs_to_spatialreference
+
+# -- GLOBALS --
 
 
 class TileMatrix:
@@ -212,8 +218,8 @@ def __init__(self, name: str) -> None:
             self.srs = data["crs"]
             self.sr = srs_to_spatialreference(self.srs)
             self.levels = {}
-            for l in data["tileMatrices"]:
-                lev = TileMatrix(l, self)
+            for level in data["tileMatrices"]:
+                lev = TileMatrix(level, self)
                 self.levels[lev.id] = lev
 
             if len(self.levels.keys()) == 0:
@@ -232,7 +238,7 @@ def __init__(self, name: str) -> None:
 
         except RuntimeError as e:
             raise Exception(
-                f"Wrong attribute 'crs' ('{self.srs}') in '{self.path}', not recognize by OSR"
+                f"Wrong attribute 'crs' ('{self.srs}') in '{self.path}', not recognize by OSR. Trace : {e}"
             )
 
     def get_level(self, level_id: str) -> "TileMatrix":
diff --git a/src/rok4/utils.py b/src/rok4/utils.py
index 004852b..40c7884 100644
--- a/src/rok4/utils.py
+++ b/src/rok4/utils.py
@@ -1,18 +1,23 @@
 """Provide functions to manipulate OGR / OSR entities
 """
+# -- IMPORTS --
 
+# standard library
 import os
 import re
-from typing import Dict, List, Tuple, Union
+from typing import Tuple
 
+# 3rd party
 from osgeo import gdal, ogr, osr
 
+# package
+from rok4.enums import ColorFormat
+
+# -- GLOBALS --
 ogr.UseExceptions()
 osr.UseExceptions()
 gdal.UseExceptions()
 
-from rok4.enums import ColorFormat
-
 __SR_BOOK = {}
 
 
@@ -187,7 +192,7 @@ def compute_bbox(source_dataset: gdal.Dataset) -> Tuple:
     transform_vector = source_dataset.GetGeoTransform()
     if transform_vector is None:
         raise Exception(
-            f"No transform vector found in the dataset created from "
+            "No transform vector found in the dataset created from "
             + f"the following file : {source_dataset.GetFileList()[0]}"
         )
     width = source_dataset.RasterXSize
diff --git a/src/rok4/vector.py b/src/rok4/vector.py
index 2cdb0a2..268d181 100644
--- a/src/rok4/vector.py
+++ b/src/rok4/vector.py
@@ -6,17 +6,23 @@
 
 """
 
+# -- IMPORTS --
+
+# standard library
 import os
 import tempfile
 
+# 3rd party
 from osgeo import ogr
 
+# package
+from rok4.storage import copy, get_osgeo_path
+
+# -- GLOBALS --
+
 # Enable GDAL/OGR exceptions
 ogr.UseExceptions()
 
-from rok4.exceptions import *
-from rok4.storage import copy, get_osgeo_path
-
 
 class Vector:
     """A data vector
@@ -137,7 +143,7 @@ def from_file(cls, path: str, **kwargs) -> "Vector":
                         vrt_file += "<SrcDataSource>" + tmp_path + ".csv</SrcDataSource>\n"
                         vrt_file += "<SrcLayer>" + name_fich + "</SrcLayer>\n"
                         vrt_file += "<LayerSRS>" + srs + "</LayerSRS>\n"
-                        if column_wkt == None:
+                        if column_wkt is None:
                             vrt_file += (
                                 '<GeometryField encoding="PointFromColumns" x="'
                                 + column_x
@@ -184,7 +190,7 @@ def from_file(cls, path: str, **kwargs) -> "Vector":
                 attributes += [(fieldName, fieldType)]
             for feature in layer:
                 geom = feature.GetGeometryRef()
-                if geom != None:
+                if geom is not None:
                     multipolygon.AddGeometry(geom)
             layers += [(name, count, attributes)]
 

From b02dbc2b010ba417233eb85307f40b2900490ac0 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 17:44:11 +0200
Subject: [PATCH 72/89] Fix linters errors and close #54

---
 src/rok4/layer.py           |  2 +-
 src/rok4/pyramid.py         | 27 +++++++++++++++------------
 src/rok4/tile_matrix_set.py |  2 +-
 3 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/rok4/layer.py b/src/rok4/layer.py
index dfccac9..c6c21ed 100644
--- a/src/rok4/layer.py
+++ b/src/rok4/layer.py
@@ -233,7 +233,7 @@ def __load_pyramids(self, pyramids: List[Dict[str, str]]) -> None:
                 {"pyramid": pyramid, "bottom_level": bottom_level, "top_level": top_level}
             )
 
-        self.__best_level = sorted(self.__levels.values(), key=lambda l: l.resolution)[0]
+        self.__best_level = sorted(self.__levels.values(), key=lambda level: level.resolution)[0]
 
     def __str__(self) -> str:
         return f"{self.type.name} layer '{self.__name}'"
diff --git a/src/rok4/pyramid.py b/src/rok4/pyramid.py
index 7566e93..c87da7a 100644
--- a/src/rok4/pyramid.py
+++ b/src/rok4/pyramid.py
@@ -28,13 +28,16 @@
 from rok4.exceptions import FormatError, MissingAttributeError
 from rok4.storage import (
     copy,
+    get_data_binary,
     get_data_str,
     get_infos_from_path,
     get_path_from_infos,
     put_data_str,
     remove,
+    size_path,
 )
 from rok4.tile_matrix_set import TileMatrix, TileMatrixSet
+from rok4.utils import reproject_point, srs_to_spatialreference
 
 # -- GLOBALS --
 ROK4_IMAGE_HEADER_SIZE = 2048
@@ -528,7 +531,7 @@ def from_other(cls, other: "Pyramid", name: str, storage: Dict) -> "Pyramid":
                 pyramid.__levels[lev.id] = lev
 
         except KeyError as e:
-            raise MissingAttributeError(descriptor, e)
+            raise MissingAttributeError(pyramid.descriptor, e)
 
         return pyramid
 
@@ -553,7 +556,9 @@ def serializable(self) -> Dict:
         serialization = {"tile_matrix_set": self.__tms.name, "format": self.__format}
 
         serialization["levels"] = []
-        sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution, reverse=True)
+        sorted_levels = sorted(
+            self.__levels.values(), key=lambda level: level.resolution, reverse=True
+        )
 
         for level in sorted_levels:
             serialization["levels"].append(level.serializable)
@@ -652,9 +657,7 @@ def storage_depth(self, d: int) -> None:
             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"
-            )
+            raise Exception(f"Pyramid {self.__descriptor} owns levels with different path depths")
         self.__storage["depth"] = d
 
     @property
@@ -696,7 +699,7 @@ def bottom_level(self) -> "Level":
         Returns:
             Level: the bottom level
         """
-        return sorted(self.__levels.values(), key=lambda l: l.resolution)[0]
+        return sorted(self.__levels.values(), key=lambda level: level.resolution)[0]
 
     @property
     def top_level(self) -> "Level":
@@ -705,7 +708,7 @@ def top_level(self) -> "Level":
         Returns:
             Level: the top level
         """
-        return sorted(self.__levels.values(), key=lambda l: l.resolution)[-1]
+        return sorted(self.__levels.values(), key=lambda level: level.resolution)[-1]
 
     @property
     def type(self) -> PyramidType:
@@ -875,7 +878,7 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
             List[Level]: asked sorted levels
         """
 
-        sorted_levels = sorted(self.__levels.values(), key=lambda l: l.resolution)
+        sorted_levels = sorted(self.__levels.values(), key=lambda level: level.resolution)
 
         levels = []
 
@@ -894,13 +897,13 @@ def get_levels(self, bottom_id: str = None, top_id: str = None) -> List[Level]:
 
         end = False
 
-        for l in sorted_levels:
-            if not begin and l.id == bottom_id:
+        for level in sorted_levels:
+            if not begin and level.id == bottom_id:
                 begin = True
 
             if begin:
-                levels.append(l)
-                if top_id is not None and l.id == top_id:
+                levels.append(level)
+                if top_id is not None and level.id == top_id:
                     end = True
                     break
                 else:
diff --git a/src/rok4/tile_matrix_set.py b/src/rok4/tile_matrix_set.py
index 14bae9f..84a3d22 100644
--- a/src/rok4/tile_matrix_set.py
+++ b/src/rok4/tile_matrix_set.py
@@ -255,4 +255,4 @@ def get_level(self, level_id: str) -> "TileMatrix":
 
     @property
     def sorted_levels(self) -> List[TileMatrix]:
-        return sorted(self.levels.values(), key=lambda l: l.resolution)
+        return sorted(self.levels.values(), key=lambda level: level.resolution)

From 0346e08b37dd68bb41b518395ffa6fe92fed9a5b Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 17:48:36 +0200
Subject: [PATCH 73/89] Add config section for pre-commit.ci

---
 .pre-commit-config.yaml | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3bbe193..4402755 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -27,7 +27,6 @@ repos:
       - id: black
         args: ["--target-version=py38"]
 
-
   - repo: https://github.com/pycqa/isort
     rev: 5.12.0
     hooks:
@@ -40,3 +39,9 @@ repos:
       - id: pyupgrade
         args:
           - "--py38-plus"
+
+ci:
+  autofix_commit_msg: "[pre-commit.ci] Corrections automatiques appliquées par les git hooks."
+  autofix_prs: true
+  autoupdate_commit_msg: "[pre-commit.ci] Mise à jour des git hooks."
+  autoupdate_schedule: quarterly

From dcfd60975d4e8990c2756438d7dc5270a71bc387 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 17:58:59 +0200
Subject: [PATCH 74/89] Add ruff git hook

---
 .pre-commit-config.yaml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3bbe193..9f470f7 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -21,6 +21,12 @@ repos:
       - id: trailing-whitespace
         args: [--markdown-linebreak-ext=md]
 
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: "v0.0.281"
+    hooks:
+      - id: ruff
+        args: ["--fix-only", "--target-version=py38"]
+
   - repo: https://github.com/psf/black
     rev: 23.3.0
     hooks:

From 86009615ed1d435a384ac19c9c67cecefdcfd5be Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 17:59:19 +0200
Subject: [PATCH 75/89] Add ruff as dev dependency and configuration

---
 pyproject.toml | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 029bfdf..ce31c97 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -46,7 +46,8 @@ doc = [
 dev = [
   "black",
   "isort >= 5.12.0",
-  "pre-commit >3,<4"
+  "pre-commit >3,<4",
+  "ruff >= 0.0.281"
 ]
 
 test = [
@@ -68,5 +69,14 @@ build-backend = "setuptools.build_meta"
 line-length = 100
 target-version = ['py38']
 
+[tool.ruff]
+line-length = 100
+src = ["src"]
+target-version = "py38"
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
 [tool.setuptools.packages.find]
 where = ["src"]

From faf1a933b016b383b61d3530ea49fce51af83f54 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Tue, 29 Aug 2023 17:07:46 +0200
Subject: [PATCH 76/89] Handle missing python rados

---
 src/rok4/storage.py | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index 3b17bea..cc44ddf 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -30,24 +30,36 @@
 To precise the cluster to use, bucket name should be bucket_name@s3.storage.fr or bucket_name@s4.storage.fr. If no host is defined (no @) in the bucket name, first S3 cluster is used
 """
 
-# -- IMPORTS --
-
-# standard library
 import hashlib
 import os
 import re
 import tempfile
 from shutil import copyfile
-from typing import Dict, Tuple, Union
+from typing import Dict, List, Tuple, Union
 
-# 3rd party
 import boto3
 import botocore.exceptions
+import tempfile
+import re
+import os
 import rados
+import hashlib
 import requests
+from typing import Dict, List, Tuple, Union
+from shutil import copyfile
 from osgeo import gdal
 
-# package
+# conditional import
+try:
+    import rados
+
+    CEPH_RADOS_AVAILABLE: bool = True
+except ImportError:
+    CEPH_RADOS_AVAILABLE: bool = False
+    rados = None
+
+gdal.UseExceptions()
+
 from rok4.enums import StorageType
 from rok4.exceptions import MissingEnvironmentError, StorageError
 

From 18fe8104af9f6138bcab4280d7586f47ce5d11aa Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Wed, 30 Aug 2023 14:48:23 +0200
Subject: [PATCH 77/89] Rm useless and failing rados import

---
 src/rok4/storage.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index cc44ddf..2c02f09 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -39,11 +39,6 @@
 
 import boto3
 import botocore.exceptions
-import tempfile
-import re
-import os
-import rados
-import hashlib
 import requests
 from typing import Dict, List, Tuple, Union
 from shutil import copyfile

From 6376acef754635ee4862c0755ecd36ec6d234c5a Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Thu, 31 Aug 2023 14:47:44 +0200
Subject: [PATCH 78/89] Fix imports

---
 src/rok4/storage.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index 2c02f09..baecc1f 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -35,13 +35,11 @@
 import re
 import tempfile
 from shutil import copyfile
-from typing import Dict, List, Tuple, Union
+from typing import Dict, Tuple, Union
 
 import boto3
 import botocore.exceptions
 import requests
-from typing import Dict, List, Tuple, Union
-from shutil import copyfile
 from osgeo import gdal
 
 # conditional import

From 89936461878a1d14e3cd783c8765a1ca47c2a187 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Thu, 31 Aug 2023 14:49:43 +0200
Subject: [PATCH 79/89] Clean globals

---
 src/rok4/storage.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index baecc1f..6ea0faf 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -51,8 +51,7 @@
     CEPH_RADOS_AVAILABLE: bool = False
     rados = None
 
-gdal.UseExceptions()
-
+# package
 from rok4.enums import StorageType
 from rok4.exceptions import MissingEnvironmentError, StorageError
 
@@ -60,6 +59,9 @@
 
 # Enable GDAL/OGR exceptions
 gdal.UseExceptions()
+
+__CEPH_CLIENT = None
+__CEPH_IOCTXS = {}
 __S3_CLIENTS = {}
 __S3_DEFAULT_CLIENT = None
 
@@ -144,10 +146,6 @@ def disconnect_s3_clients() -> None:
     __S3_DEFAULT_CLIENT = None
 
 
-__CEPH_CLIENT = None
-__CEPH_IOCTXS = {}
-
-
 def __get_ceph_ioctx(pool: str) -> "rados.Ioctx":
     """Get the CEPH IO context
 

From 4d805233521da5ce24a75cbbe41433ec8b559893 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Thu, 31 Aug 2023 14:53:34 +0200
Subject: [PATCH 80/89] Move globals vars upper

---
 src/rok4/storage.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index 6ea0faf..8b1d047 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -62,6 +62,7 @@
 
 __CEPH_CLIENT = None
 __CEPH_IOCTXS = {}
+__OBJECT_SYMLINK_SIGNATURE = "SYMLINK#"
 __S3_CLIENTS = {}
 __S3_DEFAULT_CLIENT = None
 

From 4a84dc3268581bd115892057500427e8033d0314 Mon Sep 17 00:00:00 2001
From: Julien Moura <julien.moura@oslandia.com>
Date: Thu, 31 Aug 2023 14:56:07 +0200
Subject: [PATCH 81/89] Rm duplicated var

---
 src/rok4/storage.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index 8b1d047..8fda078 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -195,9 +195,6 @@ def disconnect_ceph_clients() -> None:
     __CEPH_IOCTXS = {}
 
 
-__OBJECT_SYMLINK_SIGNATURE = "SYMLINK#"
-
-
 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)
 

From 7e64927926fcd6a22f1de0ca6411e361cc00bedc Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 1 Sep 2023 10:32:28 +0200
Subject: [PATCH 82/89] =?UTF-8?q?Pas=20de=20documentation=20publi=C3=A9e?=
 =?UTF-8?q?=20pour=20les=20versions=20beta?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .github/workflows/build-and-release.yaml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 8fb0b1e..8f8d8af 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -3,7 +3,8 @@ name: Test, build and publish artefacts and documentation
 on:
   push:
     tags:
-      - '**'
+      - '[0-9]+.[0-9]+.[0-9]+'
+      - '[0-9]+.[0-9]+.[0-9]+-beta[0-9]+'
 
 jobs:
 
@@ -158,7 +159,7 @@ jobs:
   commit_documentation:
     name: Add documentation and unit tests results into gh-pages branch
     needs: build_and_test
-    if: "always()&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
+    if: "always()&&!contains(${{ github.ref_name }},'beta')&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
     runs-on: ubuntu-latest
 
     steps:

From 0040040b417074c16e6eff9b9ca7faf5eb101186 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 1 Sep 2023 10:53:43 +0200
Subject: [PATCH 83/89] Correction des tests unitaires

---
 .github/workflows/build-and-release.yaml | 2 +-
 tests/test_raster.py                     | 4 ++--
 tests/test_tile_matrix_set.py            | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 8f8d8af..5dea00b 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -27,7 +27,7 @@ jobs:
           name: Release ${{ github.ref_name }}
           generateReleaseNotes: true
           draft: false
-          prerelease: false
+          prerelease: contains(${{ github.ref_name }},'beta')
 
   build_and_test:
 
diff --git a/tests/test_raster.py b/tests/test_raster.py
index 8bf80f0..85b71d4 100644
--- a/tests/test_raster.py
+++ b/tests/test_raster.py
@@ -332,7 +332,7 @@ def test_ok_at_least_3_files(self, m_from_file, m_get_osgeo_path):
         serial_out = rasterset.serializable
         assert rasterset.srs == srs
         m_get_osgeo_path.assert_called_once_with(list_path)
-        m_open.assert_called_once_with(file=list_local_path, mode="r")
+        m_open.assert_called_once_with(file=list_local_path)
         assert rasterset.raster_list == raster_list
         assert isinstance(serial_out["bbox"], list)
         for i in range(0, 4, 1):
@@ -405,7 +405,7 @@ def test_simple_ok(self, m_from_parameters, m_get_osgeo_path):
             rasterset = RasterSet.from_descriptor(desc_path)
 
         m_get_osgeo_path.assert_called_once_with(desc_path)
-        m_open.assert_called_once_with(file=local_path, mode="r")
+        m_open.assert_called_once_with(file=local_path)
         assert rasterset.srs == serial_in["srs"]
         m_from_parameters.assert_called()
         assert m_from_parameters.call_count == 3
diff --git a/tests/test_tile_matrix_set.py b/tests/test_tile_matrix_set.py
index faf03f1..0748128 100644
--- a/tests/test_tile_matrix_set.py
+++ b/tests/test_tile_matrix_set.py
@@ -66,7 +66,7 @@ def test_wrong_crs(mocked_get_data_str):
         tms = TileMatrixSet("tms")
     assert (
         str(exc.value)
-        == "Wrong attribute 'crs' ('epsg:123456') in 'file:///path/to/tms.json', not recognize by OSR"
+        == "Wrong attribute 'crs' ('epsg:123456') in 'file:///path/to/tms.json', not recognize by OSR. Trace : PROJ: proj_create_from_database: crs not found"
     )
     mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
 

From 3b8ef7405dc044f2eac6f05234dba2a86a837704 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 1 Sep 2023 11:33:55 +0200
Subject: [PATCH 84/89] Correction de l'injection de version beta

---
 .bumpversion.cfg                         | 10 ++++++++++
 .github/workflows/build-and-release.yaml |  5 ++---
 2 files changed, 12 insertions(+), 3 deletions(-)
 create mode 100644 .bumpversion.cfg

diff --git a/.bumpversion.cfg b/.bumpversion.cfg
new file mode 100644
index 0000000..25ed0e2
--- /dev/null
+++ b/.bumpversion.cfg
@@ -0,0 +1,10 @@
+[bumpversion]
+parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(-beta(?P<beta>\d+))?
+serialize = 
+	{major}.{minor}.{patch}-beta{beta}
+	{major}.{minor}.{patch}
+current_version = 2.0.0-toto1
+
+[bumpversion:file:pyproject.toml]
+
+[bumpversion:file:src/rok4/__init__.py]
diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 5dea00b..dce24df 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -68,12 +68,11 @@ jobs:
           python3 -m venv .venv
           source .venv/bin/activate
           python3 -m pip install --upgrade build bump2version
-          bump2version --current-version 0.0.0 --new-version ${{ github.ref_name }} patch pyproject.toml src/rok4/__init__.py
+          bump2version --current-version 0.0.0 --new-version ${{ github.ref_name }} patch
           pip install -e .
           echo "/usr/lib/python3/dist-packages/" >.venv/lib/python${{ matrix.python-version }}/site-packages/system.pth
 
       - name: Run unit tests
-        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           pip install -e .[test]
@@ -159,7 +158,7 @@ jobs:
   commit_documentation:
     name: Add documentation and unit tests results into gh-pages branch
     needs: build_and_test
-    if: "always()&&!contains(${{ github.ref_name }},'beta')&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
+    if: "!(contains(${{ github.ref_name }},'beta'))&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
     runs-on: ubuntu-latest
 
     steps:

From 1559d1af88f1d5d8b6379a1c5a43079dbe1a3114 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 1 Sep 2023 12:40:19 +0200
Subject: [PATCH 85/89] Versionnement de beta compatible PEP440

---
 .bumpversion.cfg                         | 5 ++---
 .github/workflows/build-and-release.yaml | 6 +++---
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/.bumpversion.cfg b/.bumpversion.cfg
index 25ed0e2..33caec9 100644
--- a/.bumpversion.cfg
+++ b/.bumpversion.cfg
@@ -1,9 +1,8 @@
 [bumpversion]
-parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(-beta(?P<beta>\d+))?
+parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(b(?P<beta>\d+))?
 serialize = 
-	{major}.{minor}.{patch}-beta{beta}
+	{major}.{minor}.{patch}b{beta}
 	{major}.{minor}.{patch}
-current_version = 2.0.0-toto1
 
 [bumpversion:file:pyproject.toml]
 
diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index dce24df..4787ed7 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -4,7 +4,7 @@ on:
   push:
     tags:
       - '[0-9]+.[0-9]+.[0-9]+'
-      - '[0-9]+.[0-9]+.[0-9]+-beta[0-9]+'
+      - '[0-9]+.[0-9]+.[0-9]+b[0-9]+'
 
 jobs:
 
@@ -27,7 +27,7 @@ jobs:
           name: Release ${{ github.ref_name }}
           generateReleaseNotes: true
           draft: false
-          prerelease: contains(${{ github.ref_name }},'beta')
+          prerelease: contains(${{ github.ref_name }},'b')
 
   build_and_test:
 
@@ -158,7 +158,7 @@ jobs:
   commit_documentation:
     name: Add documentation and unit tests results into gh-pages branch
     needs: build_and_test
-    if: "!(contains(${{ github.ref_name }},'beta'))&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
+    if: "!(contains(${{ github.ref_name }},'b'))&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
     runs-on: ubuntu-latest
 
     steps:

From 206763f97c7cf3bbd32678fe0a70f2063eeb1eae Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 8 Sep 2023 13:24:00 +0200
Subject: [PATCH 86/89] Correction de la lecture d'une tuile d'unepyramide PNG
 1 canal

---
 .github/workflows/build-and-release.yaml | 12 ++++++------
 src/rok4/pyramid.py                      | 10 ++++++++++
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/build-and-release.yaml b/.github/workflows/build-and-release.yaml
index 4787ed7..eb7796c 100644
--- a/.github/workflows/build-and-release.yaml
+++ b/.github/workflows/build-and-release.yaml
@@ -27,7 +27,7 @@ jobs:
           name: Release ${{ github.ref_name }}
           generateReleaseNotes: true
           draft: false
-          prerelease: contains(${{ github.ref_name }},'b')
+          prerelease: ${{ contains(github.ref_name ,'b') }}
 
   build_and_test:
 
@@ -80,7 +80,7 @@ jobs:
           coverage report -m
 
       - name: Build unit tests report
-        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
+        if: "! contains(github.ref_name,'b') && matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           coverage html -d dist/tests/
@@ -93,7 +93,7 @@ jobs:
           python3 -m build
 
       - name: Build documentation
-        if: "matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
+        if: "! contains(github.ref_name,'b') && matrix.os == 'ubuntu-20.04' && matrix.python-version == '3.8'"
         run: |
           source .venv/bin/activate
           pip install -e .[doc]
@@ -112,7 +112,7 @@ jobs:
   publish_artefacts:
     name: Add built artefacts to release and PyPI
     needs: [create_release, build_and_test]
-    if: "always()&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
+    if: "always() && needs.create_release.outputs.job_status == 'success' && needs.build_and_test.outputs.job_status == 'success'"
     runs-on: ubuntu-latest
 
     steps:
@@ -158,7 +158,7 @@ jobs:
   commit_documentation:
     name: Add documentation and unit tests results into gh-pages branch
     needs: build_and_test
-    if: "!(contains(${{ github.ref_name }},'b'))&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status=='success')"
+    if: "always() && ! contains(github.ref_name,'b') && needs.create_release.outputs.job_status == 'success' && needs.build_and_test.outputs.job_status == 'success'"
     runs-on: ubuntu-latest
 
     steps:
@@ -208,7 +208,7 @@ jobs:
   delete_version:
     name: Remove release and tag if error occured
     needs: build_and_test
-    if: "always()&&(needs.create_release.outputs.job_status=='success')&&(needs.build_and_test.outputs.job_status!='success')"
+    if: "always() && needs.create_release.outputs.job_status == 'success' && needs.build_and_test.outputs.job_status != 'success'"
     runs-on: ubuntu-latest
 
     steps:
diff --git a/src/rok4/pyramid.py b/src/rok4/pyramid.py
index c87da7a..f55433f 100644
--- a/src/rok4/pyramid.py
+++ b/src/rok4/pyramid.py
@@ -1189,6 +1189,11 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
                 raise FormatError("JPEG", "binary tile", e)
 
             data = numpy.asarray(img)
+            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_UINT8":
             data = numpy.frombuffer(binary_tile, dtype=numpy.dtype("uint8"))
@@ -1205,6 +1210,11 @@ def get_tile_data_raster(self, level: str, column: int, row: int) -> numpy.ndarr
                 raise FormatError("PNG", "binary tile", e)
 
             data = numpy.asarray(img)
+            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_UINT8":
             try:

From 2e2a202ecb611ae1c80e05ce2d0f1949222024c3 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 8 Sep 2023 11:28:38 +0000
Subject: [PATCH 87/89] =?UTF-8?q?[pre-commit.ci]=20Corrections=20automatiq?=
 =?UTF-8?q?ues=20appliqu=C3=A9es=20par=20les=20git=20hooks.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .bumpversion.cfg              |  2 +-
 tests/test_layer.py           |  2 --
 tests/test_pyramid.py         | 19 +++++++++----------
 tests/test_raster.py          |  2 +-
 tests/test_storage.py         | 23 +++++++++++------------
 tests/test_tile_matrix_set.py | 24 ++++++++++++------------
 tests/test_utils.py           | 13 ++++++-------
 tests/test_vector.py          | 10 +++++-----
 8 files changed, 45 insertions(+), 50 deletions(-)

diff --git a/.bumpversion.cfg b/.bumpversion.cfg
index 33caec9..2e04fb3 100644
--- a/.bumpversion.cfg
+++ b/.bumpversion.cfg
@@ -1,6 +1,6 @@
 [bumpversion]
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(b(?P<beta>\d+))?
-serialize = 
+serialize =
 	{major}.{minor}.{patch}b{beta}
 	{major}.{minor}.{patch}
 
diff --git a/tests/test_layer.py b/tests/test_layer.py
index 9cd314b..a4df1b3 100644
--- a/tests/test_layer.py
+++ b/tests/test_layer.py
@@ -2,8 +2,6 @@
 from unittest import mock
 from unittest.mock import *
 
-import pytest
-
 from rok4.enums import PyramidType
 from rok4.exceptions import *
 from rok4.layer import Layer
diff --git a/tests/test_pyramid.py b/tests/test_pyramid.py
index e71dd15..f44eed7 100644
--- a/tests/test_pyramid.py
+++ b/tests/test_pyramid.py
@@ -7,14 +7,13 @@
 from rok4.enums import SlabType, StorageType
 from rok4.exceptions import *
 from rok4.pyramid import *
-from rok4.tile_matrix_set import TileMatrixSet
 from rok4.utils import *
 
 
 @mock.patch("rok4.pyramid.get_data_str", side_effect=StorageError("FILE", "Not found"))
 def test_wrong_file(mocked_get_data_str):
     with pytest.raises(StorageError):
-        pyramid = Pyramid.from_descriptor("file:///pyramid.json")
+        Pyramid.from_descriptor("file:///pyramid.json")
 
 
 @mock.patch(
@@ -23,7 +22,7 @@ def test_wrong_file(mocked_get_data_str):
 )
 def test_bad_json(mocked_get_data_str):
     with pytest.raises(FormatError) as exc:
-        pyramid = Pyramid.from_descriptor("file:///pyramid.json")
+        Pyramid.from_descriptor("file:///pyramid.json")
 
     assert (
         str(exc.value)
@@ -35,7 +34,7 @@ def test_bad_json(mocked_get_data_str):
 @mock.patch("rok4.pyramid.get_data_str", return_value='{"format": "TIFF_PBF_MVT","levels":[]}')
 def test_missing_tms(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
-        pyramid = Pyramid.from_descriptor("file:///pyramid.json")
+        Pyramid.from_descriptor("file:///pyramid.json")
 
     assert str(exc.value) == "Missing attribute 'tile_matrix_set' in 'file:///pyramid.json'"
     mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
@@ -49,7 +48,7 @@ def test_missing_tms(mocked_get_data_str):
 @mock.patch("rok4.pyramid.TileMatrixSet", side_effect=StorageError("FILE", "TMS not found"))
 def test_wrong_tms(mocked_tms_constructor, mocked_get_data_str):
     with pytest.raises(StorageError) as exc:
-        pyramid = Pyramid.from_descriptor("file:///pyramid.json")
+        Pyramid.from_descriptor("file:///pyramid.json")
 
     assert str(exc.value) == "Issue occured using a FILE storage : TMS not found"
     mocked_tms_constructor.assert_called_once_with("PM")
@@ -64,7 +63,7 @@ def test_wrong_tms(mocked_tms_constructor, mocked_get_data_str):
 @mock.patch("rok4.pyramid.TileMatrixSet")
 def test_raster_missing_raster_specifications(mocked_tms_class, mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
-        pyramid = Pyramid.from_descriptor("file:///pyramid.json")
+        Pyramid.from_descriptor("file:///pyramid.json")
 
     assert str(exc.value) == "Missing attribute 'raster_specifications' in 'file:///pyramid.json'"
     mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
@@ -83,7 +82,7 @@ def test_wrong_level(mocked_tms_class, mocked_get_data_str):
     mocked_tms_class.return_value = tms_instance
 
     with pytest.raises(Exception) as exc:
-        pyramid = Pyramid.from_descriptor("file:///pyramid.json")
+        Pyramid.from_descriptor("file:///pyramid.json")
 
     mocked_tms_class.assert_called_once_with("PM")
     mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
@@ -102,7 +101,7 @@ def test_wrong_level(mocked_tms_class, mocked_get_data_str):
 @mock.patch("rok4.pyramid.TileMatrixSet", autospec=True)
 def test_vector_missing_tables(mocked_tms_class, mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
-        pyramid = Pyramid.from_descriptor("file:///pyramid.json")
+        Pyramid.from_descriptor("file:///pyramid.json")
 
     assert str(exc.value) == "Missing attribute levels[].'tables' in 'file:///pyramid.json'"
     mocked_get_data_str.assert_called_once_with("file:///pyramid.json")
@@ -119,7 +118,7 @@ def test_raster_ok(mocked_put_data_str, mocked_tms_class, mocked_get_data_str):
     tms_instance = MagicMock()
     tms_instance.name = "PM"
     tms_instance.srs = "EPSG:3857"
-    tms_instance.sr = sr_src = srs_to_spatialreference("EPSG:3857")
+    tms_instance.sr = srs_to_spatialreference("EPSG:3857")
 
     tm_instance = MagicMock()
     tm_instance.id = "0"
@@ -191,7 +190,7 @@ def test_vector_ok(mocked_tms_class, mocked_get_data_str):
     except Exception as exc:
         assert False, f"Pyramid creation raises an exception: {exc}"
 
-    with pytest.raises(Exception) as exc:
+    with pytest.raises(Exception):
         pyramid.get_tile_data_raster("12", 5, 6)
 
 
diff --git a/tests/test_raster.py b/tests/test_raster.py
index 85b71d4..3222bc2 100644
--- a/tests/test_raster.py
+++ b/tests/test_raster.py
@@ -10,7 +10,7 @@
 import math
 import random
 from unittest import TestCase, mock
-from unittest.mock import MagicMock, Mock, call, mock_open, patch
+from unittest.mock import MagicMock, call, mock_open
 
 import pytest
 
diff --git a/tests/test_storage.py b/tests/test_storage.py
index f2649e5..f5c4889 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -4,7 +4,6 @@
 
 import botocore.exceptions
 import pytest
-from rados import ObjectNotFound
 
 from rok4.enums import StorageType
 from rok4.exceptions import *
@@ -55,13 +54,13 @@ def test_get_path_from_infos():
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_s3_missing_env():
     with pytest.raises(MissingEnvironmentError):
-        data = get_data_str("s3://bucket/path/to/object")
+        get_data_str("s3://bucket/path/to/object")
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_ceph_missing_env():
     with pytest.raises(MissingEnvironmentError):
-        data = get_data_str("ceph://bucket/path/to/object")
+        get_data_str("ceph://bucket/path/to/object")
 
 
 @mock.patch.dict(
@@ -71,7 +70,7 @@ def test_ceph_missing_env():
 )
 def test_s3_invalid_envs():
     with pytest.raises(StorageError):
-        data = get_data_str("s3://bucket/path/to/object")
+        get_data_str("s3://bucket/path/to/object")
 
 
 @mock.patch.dict(
@@ -79,17 +78,17 @@ def test_s3_invalid_envs():
 )
 @mock.patch("rok4.storage.boto3.client")
 def test_s3_invalid_endpoint(mocked_s3_client):
-    s3_instance = MagicMock()
+    MagicMock()
     mocked_s3_client.side_effect = Exception("Invalid URL")
     with pytest.raises(StorageError):
-        data = get_data_str("s3://bucket/path/to/object")
+        get_data_str("s3://bucket/path/to/object")
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
 @mock.patch("builtins.open", side_effect=FileNotFoundError("not_found"))
 def test_file_read_error(mock_file):
     with pytest.raises(FileNotFoundError):
-        data = get_data_str("file:///path/to/file.ext")
+        get_data_str("file:///path/to/file.ext")
 
     mock_file.assert_called_with("/path/to/file.ext", "rb")
 
@@ -117,7 +116,7 @@ def test_s3_read_nok(mocked_s3_client):
     s3_instance.get_object.side_effect = Exception("Bucket or object not found")
     mocked_s3_client.return_value = s3_instance
     with pytest.raises(StorageError):
-        data = get_data_str("s3://bucket/path/to/object")
+        get_data_str("s3://bucket/path/to/object")
 
 
 @mock.patch.dict(
@@ -171,7 +170,7 @@ def test_http_read_error(mock_http):
         requests_instance.content = "NULL"
         requests_instance.status_code = 404
         mock_http.return_value = requests_instance
-        data = get_data_str("http://path/to/file.ext")
+        get_data_str("http://path/to/file.ext")
 
     mock_http.assert_called_with("http://path/to/file.ext", stream=True)
 
@@ -179,7 +178,7 @@ def test_http_read_error(mock_http):
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_http_read_range_error():
     with pytest.raises(NotImplementedError):
-        data = get_data_binary("http://path/to/file.ext", (0, 100))
+        get_data_binary("http://path/to/file.ext", (0, 100))
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
@@ -925,7 +924,7 @@ def test_size_path_file_ok():
 
 def test_size_file_nok():
     with pytest.raises(StorageError):
-        size = size_path("file://tests/fixtures/TIFF_PBF_M")
+        size_path("file://tests/fixtures/TIFF_PBF_M")
 
 
 @mock.patch.dict(
@@ -935,7 +934,7 @@ def test_size_file_nok():
 )
 def test_size_path_ceph_nok():
     with pytest.raises(NotImplementedError):
-        size = size_path("ceph://pool/path")
+        size_path("ceph://pool/path")
 
 
 @mock.patch.dict(
diff --git a/tests/test_tile_matrix_set.py b/tests/test_tile_matrix_set.py
index 0748128..94f89f8 100644
--- a/tests/test_tile_matrix_set.py
+++ b/tests/test_tile_matrix_set.py
@@ -11,14 +11,14 @@
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_missing_env():
     with pytest.raises(MissingEnvironmentError):
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
 
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
 @mock.patch("rok4.tile_matrix_set.get_data_str", side_effect=StorageError("FILE", "Not found"))
 def test_wrong_file(mocked_get_data_str):
     with pytest.raises(StorageError):
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
 
 
 @mock.patch.dict(os.environ, {"ROK4_TMS_DIRECTORY": "file:///path/to"}, clear=True)
@@ -27,8 +27,8 @@ def test_wrong_file(mocked_get_data_str):
     return_value='"crs":"EPSG:3857","orderedAxes":["X","Y"],"id":"PM"}',
 )
 def test_bad_json(mocked_get_data_str):
-    with pytest.raises(FormatError) as exc:
-        tms = TileMatrixSet("tms")
+    with pytest.raises(FormatError):
+        TileMatrixSet("tms")
     mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
 
 
@@ -39,7 +39,7 @@ def test_bad_json(mocked_get_data_str):
 )
 def test_missing_id(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
     assert str(exc.value) == "Missing attribute 'id' in 'file:///path/to/tms.json'"
     mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
 
@@ -51,7 +51,7 @@ def test_missing_id(mocked_get_data_str):
 )
 def test_missing_crs(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
     assert str(exc.value) == "Missing attribute 'crs' in 'file:///path/to/tms.json'"
     mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
 
@@ -63,7 +63,7 @@ def test_missing_crs(mocked_get_data_str):
 )
 def test_wrong_crs(mocked_get_data_str):
     with pytest.raises(Exception) as exc:
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
     assert (
         str(exc.value)
         == "Wrong attribute 'crs' ('epsg:123456') in 'file:///path/to/tms.json', not recognize by OSR. Trace : PROJ: proj_create_from_database: crs not found"
@@ -78,7 +78,7 @@ def test_wrong_crs(mocked_get_data_str):
 )
 def test_wrong_axes_order(mocked_get_data_str):
     with pytest.raises(Exception) as exc:
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
     assert (
         str(exc.value)
         == "TMS 'file:///path/to/tms.json' own invalid axes order : only X/Y or Lon/Lat are handled"
@@ -93,7 +93,7 @@ def test_wrong_axes_order(mocked_get_data_str):
 )
 def test_missing_levels(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
     assert str(exc.value) == "Missing attribute 'tileMatrices' in 'file:///path/to/tms.json'"
     mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
 
@@ -105,7 +105,7 @@ def test_missing_levels(mocked_get_data_str):
 )
 def test_no_levels(mocked_get_data_str):
     with pytest.raises(Exception) as exc:
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
     assert str(exc.value) == "TMS 'file:///path/to/tms.json' has no level"
     mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
 
@@ -117,7 +117,7 @@ def test_no_levels(mocked_get_data_str):
 )
 def test_wrong_level(mocked_get_data_str):
     with pytest.raises(MissingAttributeError) as exc:
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
     assert str(exc.value) == "Missing attribute tileMatrices[].'id' in 'file:///path/to/tms.json'"
     mocked_get_data_str.assert_called_once_with("file:///path/to/tms.json")
 
@@ -129,7 +129,7 @@ def test_wrong_level(mocked_get_data_str):
 )
 def test_wrong_level_id(mocked_get_data_str):
     with pytest.raises(Exception) as exc:
-        tms = TileMatrixSet("tms")
+        TileMatrixSet("tms")
 
     assert (
         str(exc.value)
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 0b73b9e..584e34d 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,5 +1,4 @@
 import math
-import os
 import random
 from unittest import mock
 from unittest.mock import *
@@ -13,28 +12,28 @@
 
 def test_srs_to_spatialreference_ignf_ok():
     try:
-        sr = srs_to_spatialreference("IGNF:LAMB93")
-        sr = srs_to_spatialreference("ignf:lamb93")
+        srs_to_spatialreference("IGNF:LAMB93")
+        srs_to_spatialreference("ignf:lamb93")
     except Exception as exc:
         assert False, f"SpatialReference creation raises an exception: {exc}"
 
 
 def test_srs_to_spatialreference_epsg_ok():
     try:
-        sr = srs_to_spatialreference("EPSG:3857")
-        sr = srs_to_spatialreference("epsg:3857")
+        srs_to_spatialreference("EPSG:3857")
+        srs_to_spatialreference("epsg:3857")
     except Exception as exc:
         assert False, f"SpatialReference creation raises an exception: {exc}"
 
 
 def test_srs_to_spatialreference_ignf_nok():
     with pytest.raises(Exception):
-        sr = srs_to_spatialreference("IGNF:TOTO")
+        srs_to_spatialreference("IGNF:TOTO")
 
 
 def test_srs_to_spatialreference_epsg_nok():
     with pytest.raises(Exception):
-        sr = srs_to_spatialreference("EPSG:123456")
+        srs_to_spatialreference("EPSG:123456")
 
 
 def test_bbox_to_geometry_ok():
diff --git a/tests/test_vector.py b/tests/test_vector.py
index 8f75618..72e9c50 100644
--- a/tests/test_vector.py
+++ b/tests/test_vector.py
@@ -13,25 +13,25 @@
 def test_missing_env():
     disconnect_ceph_clients()
     with pytest.raises(MissingEnvironmentError):
-        vector = Vector.from_file("ceph:///ign_std/vector.shp")
+        Vector.from_file("ceph:///ign_std/vector.shp")
 
 
 @mock.patch("rok4.vector.copy", side_effect=StorageError("CEPH", "Not found"))
 def test_wrong_file(mocked_copy):
     with pytest.raises(StorageError):
-        vector = Vector.from_file("ceph:///vector.geojson")
+        Vector.from_file("ceph:///vector.geojson")
 
 
 def test_wrong_format():
     with pytest.raises(Exception) as exc:
-        vector = Vector.from_file("ceph:///vector.tif")
+        Vector.from_file("ceph:///vector.tif")
     assert str(exc.value) == "This format of file cannot be loaded"
 
 
 @mock.patch("rok4.vector.ogr.Open", return_value="not a shape")
 def test_wrong_content(mocked_copy):
     with pytest.raises(Exception) as exc:
-        vector = Vector.from_file("file:///vector.shp")
+        Vector.from_file("file:///vector.shp")
     assert str(exc.value) == "The content of file:///vector.shp cannot be read"
 
 
@@ -39,7 +39,7 @@ def test_wrong_content(mocked_copy):
 @mock.patch("rok4.vector.ogr.Open", return_value="not a shape")
 def test_wrong_content_ceph(mocked_open, mocked_copy):
     with pytest.raises(Exception) as exc:
-        vector = Vector.from_file("file:///vector.shp")
+        Vector.from_file("file:///vector.shp")
     assert str(exc.value) == "The content of file:///vector.shp cannot be read"
 
 

From a0a5f02b7161ef885a8b0158a8ba8c1364a780cf Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Wed, 13 Sep 2023 16:57:33 +0200
Subject: [PATCH 88/89] Client S3 avec connexions ouvertes et cache LRU de
 lecture

---
 CHANGELOG.md        |  13 ++++++
 src/rok4/storage.py | 103 +++++++++++++++++++++++++++++++-------------
 2 files changed, 87 insertions(+), 29 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 24eaed0..59c51ed 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,16 @@
+## 2.0.0
+
+### [Fixed]
+
+* Pyramid
+    * quand on lit une tuile dans une pyramide PNG 1 canal, on retourne bien aussi un numpy.array à 3 dimensions (la dernière dimension sera bien un array à un élément)
+
+### [Changed]
+
+* Storage
+    * Le client S3 garde ouverte des connexions
+    * La fonction get_data_binary a un système de cache de type LRU, avec un temps de validité de 5 minutes
+
 ## 1.7.1
 
 ### [Added]
diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index 8fda078..14c689e 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -18,6 +18,7 @@
 - ROK4_S3_KEY
 - ROK4_S3_SECRETKEY
 - ROK4_S3_URL
+- ROK4_SSL_NO_VERIFY (optionnal) with a non empty value disables certificate check.. Define PYTHONWARNINGS to "ignore:Unverified HTTPS request" to disable warnings logs
 
 To use several S3 clusters, each environment variable have to contain a list (comma-separated), with the same number of elements
 
@@ -34,12 +35,15 @@
 import os
 import re
 import tempfile
+from functools import lru_cache
 from shutil import copyfile
 from typing import Dict, Tuple, Union
 
 import boto3
 import botocore.exceptions
+
 import requests
+import time
 from osgeo import gdal
 
 # conditional import
@@ -67,6 +71,10 @@
 __S3_DEFAULT_CLIENT = None
 
 
+def __get_ttl_hash():
+    """Return the same value withing 5 minutes time period"""
+    return round(time.time() / 300)
+
 def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", str]], str, str]:
     """Get the S3 client
 
@@ -85,7 +93,13 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
 
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
 
+
     if not __S3_CLIENTS:
+
+        verify = True
+        if "ROK4_SSL_NO_VERIFY" in os.environ and os.environ["ROK4_SSL_NO_VERIFY"] != "":
+            verify = False
+
         # C'est la première fois qu'on cherche à utiliser le stockage S3, chargeons les informations depuis les variables d'environnement
         try:
             keys = os.environ["ROK4_S3_KEY"].split(",")
@@ -109,7 +123,12 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
                         "s3",
                         aws_access_key_id=keys[i],
                         aws_secret_access_key=secret_keys[i],
+                        verify=verify,
                         endpoint_url=urls[i],
+                        config=botocore.config.Config(
+                            tcp_keepalive = True,
+                            max_pool_connections = 10
+                        )
                     ),
                     "key": keys[i],
                     "secret_key": secret_keys[i],
@@ -271,6 +290,7 @@ def get_data_str(path: str) -> str:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage read issue
         FileNotFoundError: File or object does not exist
+        NotImplementedError: Storage type not handled
 
     Returns:
         str: Data content
@@ -279,17 +299,20 @@ 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:
-    """Load data into a binary string
+@lru_cache(maxsize=50)
+def __get_cached_data_binary(path: str, ttl_hash: int, range: Tuple[int, int] = None) -> str:
+    """Load data into a binary string, using a LRU cache
 
     Args:
         path (str): path to data
+        ttl_hash (int): time hash, to invalid cache
         range (Tuple[int, int], optional): offset and size, to make a partial read. Defaults to None.
 
     Raises:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage read issue
         FileNotFoundError: File or object does not exist
+        NotImplementedError: Storage type not handled
 
     Returns:
         str: Data binary content
@@ -329,7 +352,7 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
         except Exception as e:
             raise StorageError("S3", e)
 
-    elif storage_type == StorageType.CEPH:
+    elif storage_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -372,13 +395,33 @@ def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
             except Exception as e:
                 raise StorageError(storage_type.name, e)
         else:
-            raise NotImplementedError
+            raise NotImplementedError(f"Cannot get partial data for storage type HTTP(S)")
 
     else:
-        raise StorageError("UNKNOWN", "Unhandled storage type to read binary data")
+        raise NotImplementedError(f"Cannot get data for storage type {storage_type.name}")
 
     return data
 
+def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
+    """Load data into a binary string
+
+    This function uses a LRU cache, with a TTL of 5 minutes
+
+    Args:
+        path (str): path to data
+        range (Tuple[int, int], optional): offset and size, to make a partial read. Defaults to None.
+
+    Raises:
+        MissingEnvironmentError: Missing object storage informations
+        StorageError: Storage read issue
+        FileNotFoundError: File or object does not exist
+        NotImplementedError: Storage type not handled
+
+    Returns:
+        str: Data binary content
+    """
+    return __get_cached_data_binary(path, __get_ttl_hash(), range)
+
 
 def put_data_str(data: str, path: str) -> None:
     """Store string data into a file or an object
@@ -392,6 +435,7 @@ def put_data_str(data: str, path: str) -> None:
     Raises:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage write issue
+        NotImplementedError: Storage type not handled
     """
 
     storage_type, path, tray_name, base_name = get_infos_from_path(path)
@@ -406,7 +450,7 @@ def put_data_str(data: str, path: str) -> None:
         except Exception as e:
             raise StorageError("S3", e)
 
-    elif storage_type == StorageType.CEPH:
+    elif storage_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -423,7 +467,7 @@ def put_data_str(data: str, path: str) -> None:
             raise StorageError("FILE", e)
 
     else:
-        raise StorageError("UNKNOWN", "Unhandled storage type to write string data")
+        raise NotImplementedError(f"Cannot write data for storage type {storage_type.name}")
 
 
 def get_size(path: str) -> int:
@@ -435,6 +479,7 @@ def get_size(path: str) -> int:
     Raises:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage read issue
+        NotImplementedError: Storage type not handled
 
     Returns:
         int: file/object size, in bytes
@@ -453,7 +498,7 @@ def get_size(path: str) -> int:
         except Exception as e:
             raise StorageError("S3", e)
 
-    elif storage_type == StorageType.CEPH:
+    elif storage_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -478,7 +523,7 @@ def get_size(path: str) -> int:
             raise StorageError(storage_type.name, e)
 
     else:
-        raise StorageError("UNKNOWN", "Unhandled storage type to get size")
+        raise NotImplementedError(f"Cannot get size for storage type {storage_type.name}")
 
 
 def exists(path: str) -> bool:
@@ -490,6 +535,7 @@ def exists(path: str) -> bool:
     Raises:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage read issue
+        NotImplementedError: Storage type not handled
 
     Returns:
         bool: file/object existing status
@@ -509,7 +555,7 @@ def exists(path: str) -> bool:
             else:
                 raise StorageError("S3", e)
 
-    elif storage_type == StorageType.CEPH:
+    elif storage_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -534,7 +580,7 @@ def exists(path: str) -> bool:
             raise StorageError(storage_type.name, e)
 
     else:
-        raise StorageError("UNKNOWN", "Unhandled storage type to test if exists")
+        raise NotImplementedError(f"Cannot test existence for storage type {storage_type.name}")
 
 
 def remove(path: str) -> None:
@@ -546,6 +592,7 @@ def remove(path: str) -> None:
     Raises:
         MissingEnvironmentError: Missing object storage informations
         StorageError: Storage removal issue
+        NotImplementedError: Storage type not handled
     """
     storage_type, path, tray_name, base_name = get_infos_from_path(path)
 
@@ -557,7 +604,7 @@ def remove(path: str) -> None:
         except Exception as e:
             raise StorageError("S3", e)
 
-    elif storage_type == StorageType.CEPH:
+    elif storage_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         ioctx = __get_ceph_ioctx(tray_name)
 
         try:
@@ -576,7 +623,7 @@ def remove(path: str) -> None:
             raise StorageError("FILE", e)
 
     else:
-        raise StorageError("UNKNOWN", "Unhandled storage type to remove things")
+        raise NotImplementedError(f"Cannot remove data for storage type {storage_type.name}")
 
 
 def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
@@ -588,8 +635,9 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         from_md5 (str, optional): MD5 sum, re-processed after copy and controlled. Defaults to None.
 
     Raises:
-        StorageError: Unhandled copy or copy issue
+        StorageError: Copy issue
         MissingEnvironmentError: Missing object storage informations
+        NotImplementedError: Storage type not handled
     """
 
     from_type, from_path, from_tray, from_base_name = get_infos_from_path(from_path)
@@ -687,7 +735,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         except Exception as e:
             raise StorageError("S3", f"Cannot copy S3 object {from_path} to {to_path} : {e}")
 
-    elif from_type == StorageType.CEPH and to_type == StorageType.FILE:
+    elif from_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE and to_type == StorageType.FILE:
         ioctx = __get_ceph_ioctx(from_tray)
 
         if from_md5 is not None:
@@ -726,7 +774,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 "CEPH and FILE", f"Cannot copy CEPH object {from_path} to file {to_path} : {e}"
             )
 
-    elif from_type == StorageType.FILE and to_type == StorageType.CEPH:
+    elif from_type == StorageType.FILE and to_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         ioctx = __get_ceph_ioctx(to_tray)
 
         if from_md5 is not None:
@@ -763,7 +811,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
                 "FILE and CEPH", f"Cannot copy file {from_path} to CEPH object {to_path} : {e}"
             )
 
-    elif from_type == StorageType.CEPH and to_type == StorageType.CEPH:
+    elif from_type == StorageType.CEPH and to_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         from_ioctx = __get_ceph_ioctx(from_tray)
         to_ioctx = __get_ceph_ioctx(to_tray)
 
@@ -795,7 +843,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
         except Exception as e:
             raise StorageError("CEPH", f"Cannot copy CEPH object {from_path} to {to_path} : {e}")
 
-    elif from_type == StorageType.CEPH and to_type == StorageType.S3:
+    elif from_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE and to_type == StorageType.S3:
         from_ioctx = __get_ceph_ioctx(from_tray)
 
         s3_client, to_bucket = __get_s3_client(to_tray)
@@ -854,7 +902,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
 
     elif (
         from_type == StorageType.HTTP or from_type == StorageType.HTTPS
-    ) and to_type == StorageType.CEPH:
+    ) and to_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
@@ -896,10 +944,7 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             )
 
     else:
-        raise StorageError(
-            f"{from_type.name} and {to_type.name}",
-            f"Cannot copy from {from_type.name} to {to_type.name}",
-        )
+        raise NotImplementedError(f"Cannot copy data from storage type {from_type.name} to storage type {to_type.name}")
 
 
 def link(target_path: str, link_path: str, hard: bool = False) -> None:
@@ -911,8 +956,9 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
         hard (bool, optional): hard link rather than symbolic. Only for FILE storage. Defaults to False.
 
     Raises:
-        StorageError: Unhandled link or link issue
+        StorageError: link issue
         MissingEnvironmentError: Missing object storage informations
+        NotImplementedError: Storage type not handled
     """
 
     target_type, target_path, target_tray, target_base_name = get_infos_from_path(target_path)
@@ -947,7 +993,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
         except Exception as e:
             raise StorageError("S3", e)
 
-    elif target_type == StorageType.CEPH:
+    elif target_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
         ioctx = __get_ceph_ioctx(link_tray)
 
         try:
@@ -965,7 +1011,7 @@ def link(target_path: str, link_path: str, hard: bool = False) -> None:
             raise StorageError("FILE", e)
 
     else:
-        raise StorageError("UNKNOWN", "Unhandled storage type to make link")
+        raise NotImplementedError(f"Cannot make link for storage type {target_type.name}")
 
 
 def get_osgeo_path(path: str) -> str:
@@ -1013,6 +1059,7 @@ def size_path(path: str) -> int:
     Raises:
         StorageError: Unhandled link or link issue
         MissingEnvironmentError: Missing object storage informations
+        NotImplementedError: Storage type not handled
 
     Returns:
         int: size of the path
@@ -1052,9 +1099,7 @@ def size_path(path: str) -> int:
         except Exception as e:
             raise StorageError("S3", e)
 
-    elif storage_type == StorageType.CEPH:
-        raise NotImplementedError
     else:
-        raise StorageError("UNKNOWN", "Unhandled storage type to calculate size")
+        raise NotImplementedError(f"Cannot get prefix path size for storage type {storage_type.name}")
 
     return total

From 73b49d79a45c71d557829b66be1377c4af35f405 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 13 Sep 2023 15:00:40 +0000
Subject: [PATCH 89/89] =?UTF-8?q?[pre-commit.ci]=20Corrections=20automatiq?=
 =?UTF-8?q?ues=20appliqu=C3=A9es=20par=20les=20git=20hooks.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rok4/storage.py | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/rok4/storage.py b/src/rok4/storage.py
index 14c689e..fc7a775 100644
--- a/src/rok4/storage.py
+++ b/src/rok4/storage.py
@@ -35,15 +35,14 @@
 import os
 import re
 import tempfile
+import time
 from functools import lru_cache
 from shutil import copyfile
 from typing import Dict, Tuple, Union
 
 import boto3
 import botocore.exceptions
-
 import requests
-import time
 from osgeo import gdal
 
 # conditional import
@@ -75,6 +74,7 @@ def __get_ttl_hash():
     """Return the same value withing 5 minutes time period"""
     return round(time.time() / 300)
 
+
 def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", str]], str, str]:
     """Get the S3 client
 
@@ -93,9 +93,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
 
     global __S3_CLIENTS, __S3_DEFAULT_CLIENT
 
-
     if not __S3_CLIENTS:
-
         verify = True
         if "ROK4_SSL_NO_VERIFY" in os.environ and os.environ["ROK4_SSL_NO_VERIFY"] != "":
             verify = False
@@ -125,10 +123,7 @@ def __get_s3_client(bucket_name: str) -> Tuple[Dict[str, Union["boto3.client", s
                         aws_secret_access_key=secret_keys[i],
                         verify=verify,
                         endpoint_url=urls[i],
-                        config=botocore.config.Config(
-                            tcp_keepalive = True,
-                            max_pool_connections = 10
-                        )
+                        config=botocore.config.Config(tcp_keepalive=True, max_pool_connections=10),
                     ),
                     "key": keys[i],
                     "secret_key": secret_keys[i],
@@ -395,13 +390,14 @@ def __get_cached_data_binary(path: str, ttl_hash: int, range: Tuple[int, int] =
             except Exception as e:
                 raise StorageError(storage_type.name, e)
         else:
-            raise NotImplementedError(f"Cannot get partial data for storage type HTTP(S)")
+            raise NotImplementedError("Cannot get partial data for storage type HTTP(S)")
 
     else:
         raise NotImplementedError(f"Cannot get data for storage type {storage_type.name}")
 
     return data
 
+
 def get_data_binary(path: str, range: Tuple[int, int] = None) -> str:
     """Load data into a binary string
 
@@ -901,8 +897,10 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             )
 
     elif (
-        from_type == StorageType.HTTP or from_type == StorageType.HTTPS
-    ) and to_type == StorageType.CEPH and CEPH_RADOS_AVAILABLE:
+        (from_type == StorageType.HTTP or from_type == StorageType.HTTPS)
+        and to_type == StorageType.CEPH
+        and CEPH_RADOS_AVAILABLE
+    ):
         to_ioctx = __get_ceph_ioctx(to_tray)
 
         try:
@@ -944,7 +942,9 @@ def copy(from_path: str, to_path: str, from_md5: str = None) -> None:
             )
 
     else:
-        raise NotImplementedError(f"Cannot copy data from storage type {from_type.name} to storage type {to_type.name}")
+        raise NotImplementedError(
+            f"Cannot copy data from storage type {from_type.name} to storage type {to_type.name}"
+        )
 
 
 def link(target_path: str, link_path: str, hard: bool = False) -> None:
@@ -1100,6 +1100,8 @@ def size_path(path: str) -> int:
             raise StorageError("S3", e)
 
     else:
-        raise NotImplementedError(f"Cannot get prefix path size for storage type {storage_type.name}")
+        raise NotImplementedError(
+            f"Cannot get prefix path size for storage type {storage_type.name}"
+        )
 
     return total