wolfhece 2.2.28__py3-none-any.whl → 2.2.29__py3-none-any.whl

wolfhece/acceptability/func.py

@@ -14,6 +14,7 @@ from typing import Union, Literal
 from ..PyVertexvectors import Zones, zone, vector, wolfvertex, getIfromRGB
 from ..PyTranslate import _
 from ..scenario. config_manager import Config_Manager_2D_GPU
+from ..eikonal import inpaint_waterlevel, inpaint_array
 
 import subprocess
 import geopandas as gpd
@@ -28,6 +29,7 @@ from tqdm import tqdm
 from pyogrio import list_layers, read_dataframe
 from enum import Enum
 import numba as nb
+import shutil
 
 ENGINE = 'pyogrio' # or 'Fiona -- Pyogrio is faster
 EXTENT = '.gpkg'
@@ -104,14 +106,14 @@ def empty_folder(folder):
             fn = os.path.join(folder, files)
             try:
                 if os.path.isfile(fn) or os.path.islink(fn):
-                    os.unlink(fn)  
+                    os.unlink(fn)
                 elif os.path.isdir(fn):
-                    shutil.rmtree(fn)  
+                    shutil.rmtree(fn)
             except Exception as e:
                 print(f"Error when deleting file {fn}: {e}")
     else:
         print("The folder does not exist.")
-        
+
 class Accept_Manager():
     """
     Structure to store the directories and names of the files.
@@ -207,6 +209,7 @@ class Accept_Manager():
         self.IN_CSV         = self.IN_DIR / "CSVs"
         self.IN_WATER_DEPTH = self.IN_DIR / "WATER_DEPTH"
         self.IN_EPU_STATIONS= self.IN_DIR / "EPU_STATIONS_NEW"
+        self.IN_SA_INTERP   = None
 
         self.ORIGINAL_GDB   = self.IN_DATABASE / self._original_gdb
         self.CAPA_WALLOON   = self.IN_DATABASE / self._capa_walloon
@@ -410,7 +413,7 @@ class Accept_Manager():
             if Study_area in self.get_list_studyareas(with_suffix=True) or Study_area+".shp" in self.get_list_studyareas(with_suffix=True):
                 self._study_area = Path(Study_area)
             else:
-                logging.error("The study area does not exist in the study area directory")
+                logging.error(_("The study area does not exist in the study area directory"))
 
         self.create_paths()
 
@@ -422,7 +425,7 @@ class Accept_Manager():
             self.check_temporary()
             self.check_outputs()
         else:
-            logging.error("The scenario does not exist in the water depth directory")
+            logging.error(_("The scenario does not exist in the water depth directory"))
 
     def get_files_in_rm_buildings(self) -> list[Path]:
         return [Path(a) for a in glob.glob(str(self.IN_RM_BUILD_DIR / ("*"+ EXTENT)))]
@@ -471,7 +474,7 @@ class Accept_Manager():
         if self.IN_SA_INTERP.exists() :
             files = [Path(a) for a in glob.glob(str(self.IN_SA_INTERP / "*.tif"))]
         else :
-            logging.error("No such scenario")
+            logging.error(_("No such scenario"))
         return files
 
     def get_sims_files_for_baseline(self) -> list[Path]:
@@ -481,7 +484,7 @@ class Accept_Manager():
             track = Path(str(self.IN_SA_BASE_INTERP / "*.tif"))
             files = [Path(a) for a in glob.glob(str(track))]
         else :
-            logging.error("No _baseline interpolated free surfaces files")
+            logging.error(_("No _baseline interpolated free surfaces files"))
 
         return files
 
@@ -576,7 +579,7 @@ class Accept_Manager():
         # List files in directory
         sims = self.get_sims_files_for_scenario()
         sims_modif = [
-            os.path.join(os.path.dirname(path), os.path.basename(path).replace("Q", "T"))
+            os.path.join(os.path.dirname(path), os.path.basename(path).replace("Q", "T").split('_')[0])
             for path in sims
             ]
 
@@ -590,7 +593,7 @@ class Accept_Manager():
         idx_h = [Path(cursim).name.find(".tif") for cursim in sims_modif]
 
         # create the list of return periods -- only the numeric part
-        sims = [int(Path(cursim).name[idx_T[i]+1:idx_h[i]]) for i, cursim in enumerate(sims_modif)]
+        sims = [int(Path(cursim).name[idx_T[i]+1:]) for i, cursim in enumerate(sims_modif)]
         return sorted(sims)
 
     def get_modifiedrasters(self):
@@ -653,51 +656,51 @@ class Accept_Manager():
 
         err = False
         if not self.IN_DATABASE.exists():
-            logging.error("INPUT : The database directory does not exist")
+            logging.error(_("INPUT : The database directory does not exist"))
             err = True
 
         if not self.IN_STUDY_AREA.exists():
-            logging.error("INPUT : The study area directory does not exist")
+            logging.error(_("INPUT : The study area directory does not exist"))
             err = True
 
         if not self.IN_CSV.exists():
-            logging.error("INPUT : The CSV directory does not exist")
+            logging.error(_("INPUT : The CSV directory does not exist"))
             err = True
 
         if not self.IN_WATER_DEPTH.exists():
-            logging.error("INPUT : The water depth directory does not exist")
+            logging.error(_("INPUT : The water depth directory does not exist"))
             err = True
 
         if not self.IN_EPU_STATIONS.exists():
-            logging.error("INPUT : The EPU stations directory does not exist")
+            logging.error(_("INPUT : The EPU stations directory does not exist"))
             err = True
 
         if self.Study_area is not None:
             if not self.SA.exists():
-                logging.error("INPUT : The study area file does not exist")
+                logging.error(_("INPUT : The study area file does not exist"))
                 err = True
 
         if not self.ORIGINAL_GDB.exists():
-            logging.error("INPUT : The original gdb file does not exist - Please pull it from the SPW-ARNE")
+            logging.error(_("INPUT : The original gdb file does not exist - Please pull it from the SPW-ARNE"))
             err = True
 
         if not self.CAPA_WALLOON.exists():
-            logging.error("INPUT : The Cadastre Walloon file does not exist - Please pull it from the SPW")
+            logging.error(_("INPUT : The Cadastre Walloon file does not exist - Please pull it from the SPW"))
             err = True
 
         if not self.PICC_WALLOON.exists():
-            logging.error("INPUT : The PICC Walloon file does not exist - Please pull it from the SPW website")
+            logging.error(_("INPUT : The PICC Walloon file does not exist - Please pull it from the SPW website"))
             err = True
 
         if not self.CE_IGN_TOP10V.exists():
-            logging.error("INPUT : The CE IGN top10v file does not exist - Please pull it from the IGN")
+            logging.error(_("INPUT : The CE IGN top10v file does not exist - Please pull it from the IGN"))
             err = True
 
         if self.scenario is None:
             logging.debug("The scenario has not been defined")
         else:
             if not self.IN_SCEN_DIR.exists():
-                logging.error("The wd scenario directory does not exist")
+                logging.error(_("The wd scenario directory does not exist"))
                 err = True
 
         return not err
@@ -756,15 +759,15 @@ class Accept_Manager():
         """ Check if the necessary files are present before the database creation"""
 
         if not self.is_valid_inputs:
-            logging.error("Theere are missing input directories - Please check carefully the input directories and the logs")
+            logging.error(_("Theere are missing input directories - Please check carefully the input directories and the logs"))
             return False
 
         if not self.is_valid_study_area:
-            logging.error("The study area file does not exist - Please create it")
+            logging.error(_("The study area file does not exist - Please create it"))
             return False
 
         if not self.is_valid_vulnerability_csv:
-            logging.error("The vulnerability CSV file does not exist - Please create it")
+            logging.error(_("The vulnerability CSV file does not exist - Please create it"))
             return False
 
         return True
@@ -772,11 +775,11 @@ class Accept_Manager():
     def check_before_rasterize(self) -> bool:
 
         if not self.TMP_CODEVULNE.exists():
-            logging.error("The final database with vulnerability levels does not exist")
+            logging.error(_("The final database with vulnerability levels does not exist"))
             return False
 
         if not self.TMP_WMODIF.exists():
-            logging.error("The vector data with modifications does not exist")
+            logging.error(_("The vector data with modifications does not exist"))
             return False
 
         return True
@@ -784,19 +787,19 @@ class Accept_Manager():
     def check_before_vulnerability(self) -> bool:
 
         if self.SA is None:
-            logging.error("The area of interest does not exist")
+            logging.error(_("The area of interest does not exist"))
             return False
 
         if self.IN_WATER_DEPTH is None:
-            logging.error("The water depth directory does not exist")
+            logging.error(_("The water depth directory does not exist"))
             return False
 
         if self.IN_SCEN_DIR is None:
-            logging.error("The wd scenario directory does not exist in the water depth directory")
+            logging.error(_("The wd scenario directory does not exist in the water depth directory"))
             return False
 
         if self.SA_MASKED_RIVER is None:
-            logging.error("The IGN raster does not exist")
+            logging.error(_("The IGN raster does not exist"))
             return False
 
         return True
@@ -804,11 +807,11 @@ class Accept_Manager():
     def check_vuln_code_sa(self) -> bool:
 
         if not self.SA_VULN.exists():#SA_VULN
-            logging.error("The vulnerability raster file does not exist")
+            logging.error(_("The vulnerability raster file does not exist"))
             return False
 
         if not self.SA_CODE.exists():
-            logging.error("The vulnerability code raster file does not exist")
+            logging.error(_("The vulnerability code raster file does not exist"))
             return False
 
         return True
@@ -816,11 +819,11 @@ class Accept_Manager():
     def check_vuln_code_scenario(self) -> bool:
 
         if not self.TMP_VULN.exists():
-            logging.error("The vulnerability raster file does not exist")
+            logging.error(_("The vulnerability raster file does not exist"))
             return False
 
         if not self.TMP_CODE.exists():
-            logging.error("The vulnerability code raster file does not exist")
+            logging.error(_("The vulnerability code raster file does not exist"))
             return False
 
         return True
@@ -913,15 +916,15 @@ class Accept_Manager():
         vuln = self.get_files_in_rasters_vulne()
 
         if len(code) == 0:
-            logging.error("The code rasters do not exist")
+            logging.error(_("The code rasters do not exist"))
             return False
 
         if len(vuln) == 0:
-            logging.error("The vulnerability rasters do not exist")
+            logging.error(_("The vulnerability rasters do not exist"))
             return False
 
         if len(code) != len(vuln):
-            logging.error("The number of code and vulnerability rasters do not match")
+            logging.error(_("The number of code and vulnerability rasters do not match"))
             return False
 
         # we take a reference raster
@@ -941,15 +944,15 @@ class Accept_Manager():
             col_cur, row_cur = band_cur.XSize, band_cur.YSize
 
             if geo_ref != geo_cur:
-                logging.error("The geotransforms do not match {}".format(cur))
+                logging.error(_("The geotransforms do not match {}".format(cur)))
                 diff.append(cur)
 
             if proj_ref != proj_cur:
-                logging.error("The projections do not match {}".format(cur))
+                logging.error(_("The projections do not match {}".format(cur)))
                 diff.append(cur)
 
             if col_ref != col_cur or row_ref != row_cur:
-                logging.error("The dimensions do not match {}".format(cur))
+                logging.error(_("The dimensions do not match {}".format(cur)))
                 diff.append(cur)
 
         return diff
@@ -1052,77 +1055,157 @@ class Accept_Manager():
         trace = None
         if os.path.exists(self.OUT_MASKED_RIVER):
             trace = self.OUT_MASKED_RIVER
-        if os.path.exists(self.OUT_MASKED_RIVER_S):
+        elif os.path.exists(self.OUT_MASKED_RIVER_S):
             trace = self.OUT_MASKED_RIVER_S
         else :
-            logging.error("No Masked_River_extent files. Please provide them.")
+            logging.error(_("No Masked_River_extent files. Please provide them."))
         return trace
-    
+
     # Interpolation
-    # -----------------------------
-    def batch_creation_and_interpolation(self, checked_paths, iftest):
+    # -------------
+
+    def batch_creation_and_interpolation_fotran_holes(self, checked_paths:list[Path], iftest:bool) -> tuple[bool, list[str]]:
         """Creates a batch file to launch holes.exe from the selected simulations and launches it.
-                -Every files in EXTRACTED_LAST_STEP are interpolated for tests (iftest==True).
-                -Only the check simulations of the windows are interpolated for the GUI (iftest!=True)."""
+
+        - Every files in EXTRACTED_LAST_STEP are interpolated for tests (iftest==True).
+        - Only the check simulations of the windows are interpolated for the GUI (iftest!=True).
+
+        :param checked_paths: list of paths to the checked simulations
+        :param iftest: boolean to indicate if the function is called from the tests or not
+        """
+
         path_LastSteps = Path(self.IN_SA_EXTRACTED)
-        C = None
-        D = None
+
+        # Identifying the DEM and its mask
+        C = None # DEM mask
+        D = None # DEM
         for file in os.listdir(Path(self.IN_SA_DEM)):
             file_path = Path(self.IN_SA_DEM) / file
             if file_path.is_file() and file.startswith("MNT_") and file_path.suffix == ".bin":
                 if "mask" not in file:
                     D = file_path
                 else:
-                    C = file_path      
-        if D == None:
-            return logging.error("DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'")
-            
-        if C == None:
-            return logging.error("DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'")
-             
+                    C = file_path
+
+        if D is None:
+            return logging.error(_("DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'"))
+
+        if C is None:
+            return logging.error(_("DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'"))
+
         path_Interp =  Path(self.IN_SA_INTERP)
         path_bat_file = os.path.join(self.IN_SCEN_DIR, "process_files.bat")
-        
+
         if os.path.exists(path_bat_file):
             logging.info(f"The file {path_bat_file} already exists and will be replaced.")
             os.remove(path_bat_file)
-        path_code = os.path.join(self.IN_WATER_DEPTH, "holes.exe") 
+
+        path_code = os.path.join(self.IN_WATER_DEPTH, "holes.exe")
+
         A, B = [], []
-        if iftest == True:
-            #no checked box in the tests
-            path_Interp =  Path(self.IN_SA_INTERP)
-            path_LastSteps = Path(self.IN_SA_EXTRACTED)
-            A = [os.path.join(path_LastSteps,f) for f in os.listdir(path_LastSteps) if f.endswith('.bin') and not f.endswith('.bin.txt')]
-            B = [os.path.join(path_Interp, os.path.splitext(os.path.basename(f))[0]) for f in A]
-        
-        else : 
+        if iftest:
+            # no checked box in the tests
+            A = [path_LastSteps / f for f in os.listdir(path_LastSteps) if f.endswith('.bin') and not f.endswith('.bin.txt')]
+
+        else :
             for path in checked_paths:
-                parts = path.name.split("sim_") 
-                A.extend([os.path.join(path_LastSteps, g) for g in os.listdir(path_LastSteps) if g.endswith(f"{parts[1]}.bin")])
-            B = [os.path.join(path_Interp, os.path.splitext(os.path.basename(f))[0]) for f in A]
+                parts = path.name.split("sim_")
+                A.extend([path_LastSteps / g for g in os.listdir(path_LastSteps) if g.endswith(f"{parts[1]}.bin")])
+
+        B = [path_Interp / f.stem for f in A]
+
         if not A or not B or not C or not D:
-            return logging.error("Missing files.")
+            return logging.error(_("Missing files."))
+
         with open(path_bat_file, "w") as bat_file:
             for a, b in zip(A, B):
                 line = f'"{path_code}" filling in="{a}" out="{b}" mask="{C}" dem="{D} avoid_last=1"\n'
                 bat_file.write(line)
-        
+
         empty_folder(self.IN_SA_INTERP)
-        path_bat_file = os.path.join(self.IN_SCEN_DIR, "process_files.bat")
+        path_bat_file = self.IN_SCEN_DIR / "process_files.bat"
         subprocess.run([path_bat_file], check=True)
-        
+
         renamed_files = []
-        path_fichier=self.IN_SA_INTERP
+        path_fichier = self.IN_SA_INTERP
         for file in path_fichier.glob("*.tif"):
-            if "_h" in file.name:  
+            if "_h" in file.name:
                 new_name = file.stem.split("_h")[0].replace(".bin", "") + ".tif"
                 file.rename(file.with_name(new_name))
-                renamed_files.append(new_name) 
+                renamed_files.append(new_name)
+
         #deleting the other
         for file in path_fichier.glob("*.tif"):
             if "_combl" in file.name or file.name not in renamed_files:
                 file.unlink()
-                
+
+        return True, renamed_files
+
+    def batch_creation_and_interpolation_python_eikonal(self, checked_paths:list[Path], iftest:bool) -> tuple[bool, list[str]]:
+        """Creates a batch file to launch holes.exe from the selected simulations and launches it.
+
+        - Every files in EXTRACTED_LAST_STEP are interpolated for tests (iftest==True).
+        - Only the check simulations of the windows are interpolated for the GUI (iftest!=True).
+
+        :param checked_paths: list of paths to the checked simulations
+        :param iftest: boolean to indicate if the function is called from the tests or not
+        """
+
+        path_LastSteps = Path(self.IN_SA_EXTRACTED)
+
+        # Identifying the DEM and its mask
+        C = None # DEM mask
+        D = None # DEM
+        for file in os.listdir(Path(self.IN_SA_DEM)):
+            file_path = Path(self.IN_SA_DEM) / file
+            if file_path.is_file() and file.startswith("MNT_") and file_path.suffix == ".bin":
+                if "mask" not in file:
+                    D = file_path
+                else:
+                    C = file_path
+
+        if D is None:
+            return logging.error(_("DTM (.bin) not found in DTM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'"))
+
+        if C is None:
+            return logging.error(_("DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'"))
+
+        path_Interp =  Path(self.IN_SA_INTERP)
+        path_bat_file = os.path.join(self.IN_SCEN_DIR, "process_files.bat")
+
+        if os.path.exists(path_bat_file):
+            logging.info(f"The file {path_bat_file} already exists and will be replaced.")
+            os.remove(path_bat_file)
+
+        A, B = [], []
+        if iftest:
+            # no checked box in the tests
+            A = [path_LastSteps / f for f in os.listdir(path_LastSteps) if f.endswith('.bin') and not f.endswith('.bin.txt')]
+
+        else :
+            for path in checked_paths:
+                parts = path.name.split("sim_")
+                A.extend([path_LastSteps / g for g in os.listdir(path_LastSteps) if g.endswith(f"{parts[1]}.bin")])
+
+        B = [path_Interp / f.stem for f in A]
+
+        if not A or not B or not C or not D:
+            return logging.error(_("Missing files."))
+
+        renamed_files = []
+        for a, b in zip(A, B):
+            wa_a = WolfArray(a)
+            wa_c = WolfArray(C)
+            wa_d = WolfArray(D)
+            _t, _d, wh = inpaint_array(data = wa_a.array,
+                          where_compute = wa_c.array.data != wa_c.array.data[0,0],
+                          test = wa_d.array.data,
+                          ignore_last_patches= 1)
+
+            new_name = b.with_suffix(".tif")
+            wa_a.write_all(new_name)
+            renamed_files.append(new_name.name)
+
         return True, renamed_files
 
 def clip_layer(layer:str,
@@ -1171,7 +1254,7 @@ def clip_layer(layer:str,
 
         df.to_file(str(output_dir / (layer+EXTENT)), mode='w', engine=ENGINE)
     except Exception as e:
-        logging.error("Error while saving the clipped " + str(layer) + " to file")
+        logging.error(_("Error while saving the clipped " + str(layer) + " to file"))
         logging.error(e)
         pass
 
@@ -1208,7 +1291,7 @@ def data_modification(layer:str,
 
     # Read the data
     df:gpd.GeoDataFrame = gpd.read_file(input_file, engine=ENGINE)
-    nblines, _ = df.shape
+    nblines, notused = df.shape
 
     if nblines>0:
         op = manager.get_operand(input_file)
@@ -1333,7 +1416,7 @@ def data_modification(layer:str,
             if manager.is_polygons(set(df.geom_type)):
                 df.to_file(output_file, engine=ENGINE)
             else:
-                logging.error("The layer does not contains polygons - " + str(layer))
+                logging.error(_("The layer does not contains polygons - " + str(layer)))
         else:
             raise ValueError(f"The operand {op} is not recognized")
 
@@ -1341,7 +1424,7 @@ def data_modification(layer:str,
     else:
         # Normally, phase 1 does not create empty files
         # But it is better to check... ;-)
-        logging.error("skipped" + str(layer) + "due to no polygon in the study area")
+        logging.error(_("skipped" + str(layer) + "due to no polygon in the study area"))
         return "skipped" + str(layer) + "due to no polygon in the study area"
 
 def compute_vulnerability(manager:Accept_Manager):
@@ -1636,6 +1719,10 @@ def compute_acceptability(manager:Accept_Manager,
 
     points_accept = pd.read_csv(manager.POINTS_CSV)
 
+    if interval not in points_accept["Interval"]:
+        logging.error(_("The return period {} is not in the intermediate.csv file -- Please update it").format(interval))
+        return None
+
     points_accept = points_accept[points_accept["Interval"]==interval] #les wd vs Ti matrices
     points_accept = points_accept.reset_index()
 
@@ -1697,7 +1784,7 @@ def shp_to_raster(vector_fn:str | Path, raster_fn:str | Path, pixel_size:float =
     raster_path = Path(raster_fn)
 
     if not vector_path.exists():
-        logging.error(f"The vector file {vector_path} does not exist")
+        logging.error(_(f"The vector file {vector_path} does not exist"))
         return
 
     if raster_path.exists():
@@ -1807,7 +1894,7 @@ def vector_to_raster(layer:str,
     # Open the data sources and read the extents
     source_ds:ogr.DataSource = ogr.Open(vector_input)
     if source_ds is None:
-        logging.error(f"Could not open the data source {layer}")
+        logging.error(_(f"Could not open the data source {layer}"))
         return
     source_layer = source_ds.GetLayer()
 

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 28
+        self.patch = 29
 
     def __str__(self):
 

wolfhece/irm_qdf.py

@@ -9,17 +9,22 @@ copying or distribution of this file, via any medium, is strictly prohibited.
 """
 
 #Code INS des communes belges
-import numpy as np
+import re
 from os import path, mkdir
 from pathlib import Path
 from time import sleep
+from typing import Literal, Union
+import logging
+
+from tqdm import tqdm
 import pandas as pd
 import matplotlib.pyplot as plt
 from scipy.optimize import minimize,curve_fit
 from scipy.stats import gumbel_r,genextreme
-from typing import Literal
-from tqdm import tqdm
-import logging
+import numpy as np
+
+# We have tried pymupdf but its license is AGPL so it's more or less a no-go.
+import pdfplumber
 
 from .ins import Localities
 from .PyTranslate import _
@@ -749,6 +754,12 @@ class QDF_Belgium():
                 return None
 
 
+TRANSLATION_HEADER = {'année': 'year', 'janv.': 'January', 'févr.': 'February', 'mars': 'March',
+            'avr.': 'April', 'mai': 'May', 'juin': 'June',
+            'juil.': 'July', 'août': 'August', 'sept.': 'September',
+            'oct.': 'October', 'nov.': 'November', 'déc.': 'December'}
+RE_REFERENCE = re.compile(r"\([0-9]+\)")
+
 class Climate_IRM():
 
     def __init__(self, store_path= 'irm', ins:Literal['2018', '2019', '2025', 2018, 2019, 2025] = 2018) -> None:
@@ -761,7 +772,7 @@ class Climate_IRM():
         return self._climate_data[key]
 
     @classmethod
-    def importfromwebsite(cls, store_path= 'irm', verbose:bool= False, waitingtime:float= .01, ins:Literal['2018', '2019', '2025', 2018, 2019, 2025] = 2018, ins_code: int = None):
+    def importfromwebsite(cls, store_path= 'irm', verbose:bool= False, waitingtime:float= .01, ins:Literal['2018', '2019', '2025', 2018, 2019, 2025] = 2018, ins_code: int = None, convert=False):
         """ Import Excel files for one or all municipalities from the IRM website
 
         :param store_path: Where to store the downloaded data. Directory will be created if it doesn't exists.
@@ -775,6 +786,7 @@ class Climate_IRM():
 
         :param ins: The year of the INS codes to use.
         :param code: Restricts the data download to a specific NIS code. `None` means full download.
+        :param convert: Converts the downloaded PDF to Excel files.
         """
         import requests
 
@@ -800,9 +812,14 @@ class Climate_IRM():
                 if ins_code is not None and not path.exists(store_path):
                     mkdir(store_path)
 
-                file=open(path.join(store_path,str(myins)+".pdf"), 'wb')
+                pdf_file = path.join(store_path,str(myins)+".pdf")
+                file=open(pdf_file, 'wb')
                 file.write(response.content)
                 file.close()
+
+                if convert:
+                    cls._convert_irm_file(pdf_file)
+
                 if verbose:
                     if callable(verbose):
                         verbose(key/len(codes_to_load))
@@ -812,4 +829,51 @@ class Climate_IRM():
                 #logging.error(response.content)
                 logging.error(f"Failed to load IRM data: {url} --> {response}")
 
-            sleep(waitingtime)
+            if len(codes_to_load) >= 2:
+                sleep(waitingtime)
+
+    @classmethod
+    def _scrap_table(cls, t):
+        """
+        Helper method to transform a table represented as a list of list to a
+        pandas DataFrame.
+        """
+
+        def fix_cid(strings: list[str]):
+            # The CID thing is a known issue:
+            # https://github.com/euske/pdfminer/issues/122
+            return [s.replace('(cid:176)C ', '°C').replace('¢', "'") for s in strings]
+
+        nt = []
+        row_headers = []
+        for rndx in range(1, len(t)):
+            # In the row header, we remove the "references" like "(1)".
+            row_headers.append( RE_REFERENCE.sub("", t[rndx][0]) )
+
+            # The PDFs use different "minus" glyph instead of an ASCII one,
+            # let's fix it.
+            nt.append( list(map(lambda s:float(s.replace("−","-")), t[rndx][1:])))
+
+        columns_headers = map(TRANSLATION_HEADER.get, t[0][1:])
+        df = pd.DataFrame(nt, columns=fix_cid(columns_headers), index=fix_cid(row_headers))
+        return df
+
+    @classmethod
+    def _convert_irm_file(cls, pdf_file: Union[str, Path]):
+        """
+        Scrap a PDF from IRM into two tables in a single Excel file with two
+        sheets.
+        """
+        pdf_file = Path(pdf_file)
+        with pdfplumber.open(pdf_file) as pdf:
+
+            # Rain data
+            df = cls._scrap_table(pdf.pages[1].extract_table())
+
+            # Sun data
+            df_sun = cls._scrap_table(pdf.pages[4].extract_table())
+
+            dest_file = pdf_file.with_suffix('.xlsx')
+            with pd.ExcelWriter(dest_file) as writer:  # doctest: +SKIP
+                df.to_excel(writer, sheet_name='Rain')
+                df_sun.to_excel(writer, sheet_name='Sun')