From 77fb4ae2e17116ab1b2d33a1d04935c63987feb0 Mon Sep 17 00:00:00 2001
From: Theo Satabin <theo.satabin@ign.fr>
Date: Fri, 17 Mar 2023 11:24:44 +0100
Subject: [PATCH 1/2] Comparaison de float dans les tests unitaires via
 math.isclose

---
 tests/test_Utils.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

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 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 2/2] 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: