wolfhece 2.1.65__py3-none-any.whl → 2.1.67__py3-none-any.whl

wolfhece/hydrometry/kiwis.py

@@ -22,6 +22,7 @@ import numpy as np
 from enum import Enum
 from typing import Literal
 import urllib.parse
+from pathlib import Path
 
 import matplotlib.pyplot as plt
 
@@ -95,6 +96,9 @@ class kiwis_request_info(Enum):
     Formats = "Formats"
     Returnfields = "Returnfields"
     OptionalFields = "Optionalfields"
+    Subdescription = "Subdescription"
+    Dateformats = "Dateformats"
+    Transformations= "Transformations"
 
 class kiwis_token(Enum):
     ACCESS_TOKEN_KEY = 'access_token'
@@ -136,6 +140,7 @@ class kiwis_keywords_horq(Enum):
     VMAXAN      = 'an.maximum'
     VMAXANHYD   = 'anHydro.maximum'
     VMINANHYD   = 'anHydro.minimum'
+
 class kiwis_keywords_rain(Enum):
     V5_10MIN    = 'production'
     V1H         = '1h.total'
@@ -184,6 +189,22 @@ class quality_code(Enum):
     VOID            = (255, 'black', '.')
     VOID2           = (-1, 'black', '.')
 
+class station_fields(Enum):
+    STATION_ID = 'station_id'
+    STATION_NO = 'station_no'
+    STATION_NAME = 'station_name'
+    STATION_LOCAL_X = 'station_local_x'
+    STATION_LOCAL_Y = 'station_local_y'
+    STATION_LATITUDE = 'station_latitude'
+    STATION_LONGITUDE = 'station_longitude'
+    RIVER_NAME = 'river_name'
+
+class timeseries_fields(Enum):
+    TS_ID = 'ts_id'
+    TS_NAME = 'ts_name'
+    TS_UNITNAME = 'ts_unitname'
+    TS_UNITSYMBOL ='ts_unitsymbol'
+
 class hydrometry():
 
     def __init__(self, url:str=URL_SPW, urltoken:str=URL_TOKEN, credential ='', dir='') -> None:
@@ -226,15 +247,24 @@ class hydrometry():
             self.realstations = None
             pass
 
+    def __str__(self) -> str:
+        ret='Columns in stations :\n'
+        for curcol in self.realstations.columns:
+            ret+=curcol+'\n'
+        return ret
+
     def _get_commandstr(self, which:str):
+        """ Construction de la commande à envoyer au serveur KIWIS """
+
         return self.url+'?request='+which.value+'&format=json'
 
     def daily_token(self):
         """
         Get daily token to be identified on hydrometry website
 
-        @todo : manage error as response
+        #FIXME: better manage error as response
         """
+
         if self.credential == '':
             self._header = None
             return
@@ -247,64 +277,97 @@ class hydrometry():
         else:
             headers = {'Authorization' : 'Basic {}'.format(self.credential)}
             data = {'grant_type' :'client_credentials'}
-            self.token = requests.post(self.urltoken, data=data, headers=headers).json()
-            with open(today, 'w') as f:
-                json.dump(self.token, f)
+
+            try:
+                self.token = requests.post(self.urltoken, data=data, headers=headers).json()
+
+                if 'error' in self.token:
+                    self.token = None
+                    self._header = {'Authorization': 'Bearer '}
+                    return
+
+                with open(today, 'w') as f:
+                    json.dump(self.token, f)
+            except:
+                self._header = {'Authorization': 'Bearer '}
+                return
+                self.token = None
 
         self._header = {'Authorization': 'Bearer {}'.format(self.token['access_token'])}
 
     def check_plot(self):
+        """ Instance is checked in mapviewer """
         self.plotted = True
 
     def uncheck_plot(self):
+        """ Instance is unchecked in mapviewer """
         self.plotted = False
 
-    def save_struct(self,dir=''):
+    def save_struct(self, dir=''):
+        """Sauvegarde des structures dans un répertoire
+
+        :param dir: répertoire de sauvegarde
+        """
 
         if dir=='':
             return
 
-        self.sites.to_csv(join(dir,'sites.csv'))
-        self.stations.to_csv(join(dir,'stations.csv'))
-        self.groups.to_csv(join(dir,'groups.csv'))
-        self.requests.to_csv(join(dir,'requests.csv'))
+        dir = Path(dir)
+        dir.mkdir(parents=True, exist_ok=True)
 
-    def _get_stations_pythonlist(self, site_no, onlyreal=True):
+        self.sites.to_csv(dir / 'sites.csv')
+        self.stations.to_csv(dir / 'stations.csv')
+        self.groups.to_csv(dir / 'groups.csv')
+        self.requests.to_csv(dir / 'requests.csv')
+
+    def _get_stations_pythonlist(self, site_no:str|int, onlyreal:bool= True):
+        """ Obtention des stations pour le site en liste python
+
+        :param site_no: numéro du site
+        :param onlyreal: ne prendre que les stations réelles, pas les calculées
+        """
 
         if onlyreal:
-            stations = self.realstations[self.realstations['site_no']==site_no]
+            stations = self.realstations[self.realstations[kiwis_site_fields.site_no.value]==site_no]
         else:
-            stations = self.stations[self.stations['site_no']==site_no]
+            stations = self.stations[self.stations[kiwis_site_fields.site_no.value]==site_no]
 
-        list_name_code = [curname+' --- '+curno   for curname,curno in zip(stations['station_name'].values,stations['station_no'].values)]
-        list_code_name = [curno  +' --- '+curname for curname,curno in zip(stations['station_name'].values,stations['station_no'].values)]
+        list_name_code = [curname+' --- '+curno   for curname,curno in zip(stations[station_fields.STATION_NAME.value].values,stations[station_fields.STATION_NO.value].values)]
+        list_code_name = [curno  +' --- '+curname for curname,curno in zip(stations[station_fields.STATION_NAME.value].values,stations[station_fields.STATION_NO.value].values)]
 
         return list_name_code, list_code_name
 
     def _get_sites_pythonlist(self):
+        """ Obtention des sites en liste python """
 
-        list_name_code = [curname+' --- '+curno  for curname,curno in zip(self.sites['site_name'].values,self.sites['site_no'].values)]
+        list_name_code = [curname+' --- '+curno  for curname,curno in zip(self.sites[kiwis_site_fields.site_name.value].values,self.sites[kiwis_site_fields.site_no.value].values)]
         return list_name_code
 
     def get_stations(self):
-        """Obtention des stations pour le serveur courant
-
-        site_no : numéro du site ; le site correspond au réseau de mesure : DGH pour les stations du SPW-MI et DCENN pour les stations du SPW-ARNE ;
-        station_no, station_name : code et nom de la station ;
-        station_local_x, station_local_y : coordonnées de la station en Lambert belge 1972 ;
-        station_latitude,station_longitude : coordonnées de la station en ETRS89 ;
-        river_name : nom de la rivière, cette information n’est disponible que pour les stations de mesure de hauteur d’eau et de débits, les pluviomètres ne sont pas installés sur une rivière – il n’y a donc pas de nom de rivière associé ;
-        parametertype_name : type de paramètre ;
-        ts_id, ts_name : code et nom de la chronique ;
-        ts_unitname, ts_unitsymbol : nom et symbole de l’unité de mesure ;
-        ca_sta&ca_sta_returnfields=BV_DCE : nom du bassin versant principal suivi de son abréviation (2 lettres)
-        """
-
-        returnfields = 'site_no,'
-        returnfields += 'station_no,station_name,station_id,'
-        returnfields += 'station_local_x,station_local_y,'
-        returnfields += 'station_latitude,station_longitude,'
-        returnfields += 'river_name,'
+        """Obtention des stations pour le serveur courant.
+
+        Une requête sur le serveur KIWIS retourne les informations pour toutes les stations.
+        Une séparation entre station réelle et station calculée est ensuite effectuée:
+            - self.realstations
+            - self.compstations
+
+        Champs des stations :
+            - site_no : numéro du site ; le site correspond au réseau de mesure : DGH pour les stations du SPW-MI et DCENN pour les stations du SPW-ARNE ;
+            - station_no, station_name : code et nom de la station ;
+            - station_local_x, station_local_y : coordonnées de la station en Lambert belge 1972 ;
+            - station_latitude,station_longitude : coordonnées de la station en ETRS89 ;
+            - river_name : nom de la rivière, cette information n’est disponible que pour les stations de mesure de hauteur d’eau et de débits, les pluviomètres ne sont pas installés sur une rivière – il n’y a donc pas de nom de rivière associé ;
+            - parametertype_name : type de paramètre ;
+            - ts_id, ts_name : code et nom de la chronique ;
+            - ts_unitname, ts_unitsymbol : nom et symbole de l’unité de mesure ;
+            - ca_sta&ca_sta_returnfields=BV_DCE : nom du bassin versant principal suivi de son abréviation (2 lettres)
+        """
+
+        returnfields = f'{kiwis_site_fields.site_no.value},'
+        returnfields += f'{station_fields.STATION_NO.value},{station_fields.STATION_NAME.value},{station_fields.STATION_ID.value},'
+        returnfields += f'{station_fields.STATION_LOCAL_X.value},{station_fields.STATION_LOCAL_Y.value},'
+        returnfields += f'{station_fields.STATION_LATITUDE.value},{station_fields.STATION_LONGITUDE.value},'
+        returnfields += f'{station_fields.RIVER_NAME.value},'
         returnfields += 'ca_sta'
 
         ca_sta_returnfields = 'station_gauge_datum,'
@@ -327,34 +390,67 @@ class hydrometry():
             self.stations = pd.DataFrame(json_data[1:], columns = json_data[0])
 
         #Conversion en minuscules
-        self.stations['station_name']=self.stations['station_name'].str.lower()
+        self.stations[station_fields.STATION_NAME.value]=self.stations[station_fields.STATION_NAME.value].str.lower()
 
         # real stations are those with coordinates and not null
-        self.realstations = self.stations[(~pd.isnull(self.stations['station_local_x'])) & (self.stations['station_local_x']!='')]
+        self.realstations = self.stations[(~pd.isnull(self.stations[station_fields.STATION_LOCAL_X.value])) & (self.stations[station_fields.STATION_LOCAL_X.value]!='')]
         # computed stations are those without coordinates or null
-        self.compstations = self.stations[pd.isnull(self.stations['station_local_x']) | self.stations['station_local_x']!='']
+        self.compstations = self.stations[pd.isnull(self.stations[station_fields.STATION_LOCAL_X.value]) | self.stations[station_fields.STATION_LOCAL_X.value]!='']
 
     def get_names_xy(self, site_no = None):
-        """Obtention des noms et coordonnées des stations pour le site"""
+        """Obtention des noms et coordonnées des stations pour le site
+
+        :param site_no: numéro du site
+        """
+
+        if site_no is None:
+            stations_r = self.realstations
+            # stations_c = self.compstations
+        else:
+            stations_r = self.realstations[self.realstations[kiwis_site_fields.site_no.value]==site_no]
+            # stations_c = self.compstations[self.stations[kiwis_site_fields.site_no.value]==site_no]
+
+        if stations_r is None:
+            return ([],[],[])
+        else:
+            return ([curname + ' - ' + str(curid) for curname, curid in zip(stations_r[station_fields.STATION_NAME.value].values,
+                                                                            stations_r[station_fields.STATION_ID.value].values)],
+                    stations_r[station_fields.STATION_LOCAL_X.value].values,
+                    stations_r[station_fields.STATION_LOCAL_Y.value].values)
+
+    def get_names_latlon(self, site_no = None):
+        """ Obtention des noms et coordonnées des stations pour le site
+
+        :param site_no: numéro du site
+        """
 
         if site_no is None:
             stations_r = self.realstations
             # stations_c = self.compstations
         else:
-            stations_r = self.realstations[self.realstations['site_no']==site_no]
-            # stations_c = self.compstations[self.stations['site_no']==site_no]
+            stations_r = self.realstations[self.realstations[kiwis_site_fields.site_no.value]==site_no]
+            # stations_c = self.compstations[self.stations[kiwis_site_fields.site_no.value]==site_no]
 
         if stations_r is None:
             return ([],[],[])
         else:
-            return ([curname + ' - ' + str(curid) for curname, curid in zip(stations_r['station_name'].values, stations_r['station_id'].values)], stations_r['station_local_x'].values, stations_r['station_local_y'].values)
+            return ([curname + ' - ' + str(curid) for curname, curid in zip(stations_r[station_fields.STATION_NAME.value].values,
+                                                                            stations_r[station_fields.STATION_ID.value].values)],
+                    stations_r[station_fields.STATION_LATITUDE.value].values,
+                    stations_r[station_fields.STATION_LONGITUDE.value].values)
+
 
     def select_inside(self, xll:float, yll:float, xur:float, yur:float, tolist=False):
         """
         Recherche les stations dans une zone rectangulaire
 
-        xll, yll : lower left
-        xur, yur : upper right
+        :param xll: X lower left - Lambert 72
+        :param yll: Y lower left - Lambert 72
+        :param xur: X upper right - Lambert 72
+        :param yur: Y upper right - Lambert 72
+        :param tolist: retourne une liste de noms et codes de stations et nom un dataframe
+
+        :return: liste de noms et codes de stations ou dataframe
         """
 
         if xll>xur:
@@ -366,35 +462,103 @@ class hydrometry():
             yll=yur
             yur=tmpy
 
-        df = self.realstations[(self.realstations['station_local_x'].to_numpy(dtype=np.float64)>=xll) & (self.realstations['station_local_x'].to_numpy(dtype=np.float64)<=xur) & (self.realstations['station_local_y'].to_numpy(dtype=np.float64)>=yll) & (self.realstations['station_local_y'].to_numpy(dtype=np.float64)<=yur)]
+        df = self.realstations[(self.realstations[station_fields.STATION_LOCAL_X.value].to_numpy(dtype=np.float64)>=xll) & (self.realstations[station_fields.STATION_LOCAL_X.value].to_numpy(dtype=np.float64)<=xur) & \
+            (self.realstations[station_fields.STATION_LOCAL_Y.value].to_numpy(dtype=np.float64)>=yll) & (self.realstations[station_fields.STATION_LOCAL_Y.value].to_numpy(dtype=np.float64)<=yur)]
+        if tolist:
+            list_name_code = [curname+' --- '+curno  for curname,curno in zip(df[station_fields.STATION_NAME.value].values,df[station_fields.STATION_NO.value].values)]
+            return list_name_code
+        else:
+            return df
+
+    def select_inside_latlon(self, lonll:float, latll:float, lonur:float, latur:float, tolist=False):
+        """
+        Recherche les stations dans une zone rectangulaire
+
+        :param lonll: Longitude lower left - WGS84
+        :param latll: Latitude lower left - WGS84
+        :param lonur: Longitude upper right - WGS84
+        :param latur: Latitude upper right - WGS84
+        :param tolist: retourne une liste de noms et codes de stations et nom un dataframe
+
+        :return: liste de noms et codes de stations ou dataframe
+        """
+
+        if lonll>lonur:
+            tmpx=lonll
+            lonll=lonur
+            lonur=tmpx
+        if latll>latur:
+            tmpy=latll
+            latll=latur
+            latur=tmpy
+
+        df = self.realstations[(self.realstations[station_fields.STATION_LONGITUDE.value].to_numpy(dtype=np.float64)>=lonll) & (self.realstations[station_fields.STATION_LONGITUDE.value].to_numpy(dtype=np.float64)<=lonur) & \
+            (self.realstations[station_fields.STATION_LATITUDE.value].to_numpy(dtype=np.float64)>=latll) & (self.realstations[station_fields.STATION_LATITUDE.value].to_numpy(dtype=np.float64)<=latur)]
         if tolist:
-            list_name_code = [curname+' --- '+curno  for curname,curno in zip(df['station_name'].values,df['station_no'].values)]
+            list_name_code = [curname+' --- '+curno  for curname,curno in zip(df[station_fields.STATION_NAME.value].values,df[station_fields.STATION_NO.value].values)]
             return list_name_code
         else:
             return df
 
-    def sort_nearests(self,x:float,y:float):
+    def sort_nearests(self, x:float, y:float):
+        """
+        Trie les stations en fonction de la distance et retourne un index trié
+
+        :param x: coordonnée x - Lambert 72
+        :param y: coordonnée y - Lambert 72
+        """
+        dist = np.asarray([(float(cur[station_fields.STATION_LOCAL_X.value]) - x)**2 + (float(cur[station_fields.STATION_LOCAL_Y.value]) - y)**2 for idx,cur in self.realstations.iterrows()])
+        index = np.arange(len(dist))[dist.argsort()]
+
+        return index
+
+    def sort_nearests_latlon(self, lon:float, lat:float):
         """
         Trie les stations en fonction de la distance et retourne un index trié
+
+        :param lon: longitude - WGS84
+        :param lat: latitude - WGS84
         """
-        dist = np.asarray([(float(cur['station_local_x']) - x)**2 + (float(cur['station_local_y']) - y)**2 for idx,cur in self.realstations.iterrows()])
+        dist = np.asarray([(float(cur[station_fields.STATION_LATITUDE.value]) - lat)**2 + (float(cur[station_fields.STATION_LONGITUDE.value]) - lon)**2 for idx,cur in self.realstations.iterrows()])
         index = np.arange(len(dist))[dist.argsort()]
 
         return index
 
-    def find_nearest(self,x:float,y:float, tolist=False):
+    def find_nearest(self, x:float, y:float, tolist=False):
         """
         Trouve la station la plus proche
+
+        :param x: coordonnée x - Lambert 72
+        :param y: coordonnée y - Lambert 72
         """
         index = self.sort_nearests(x,y)
 
         if tolist:
-            return [self.realstations.iloc[index[0]]['station_name']+' --- '+self.realstations.iloc[index[0]]['station_no']]
+            return [self.realstations.iloc[index[0]][station_fields.STATION_NAME.value]+' --- '+self.realstations.iloc[index[0]][station_fields.STATION_NO.value]]
+        else:
+            return self.realstations.iloc[index[0]]
+
+    def find_nearest_latlon(self, lon:float, lat:float, tolist=False):
+        """
+        Trouve la station la plus proche
+
+        :param lon: longitude - WGS84
+        :param lat: latitude - WGS84
+        """
+
+        index = self.sort_nearests_latlon(lon,lat)
+
+        if tolist:
+            return [self.realstations.iloc[index[0]][station_fields.STATION_NAME.value]+' --- '+self.realstations.iloc[index[0]][station_fields.STATION_NO.value]]
         else:
             return self.realstations.iloc[index[0]]
 
     def get_timeseries_group(self, rfw:Literal['rain','waterdepth','flowrate'], time:Literal['5min','5or10min','1h','1d','1m']):
-        """Obtention des stations pour le groupe souhaité"""
+        """Obtention des stations pour le groupe souhaité
+
+        :param rfw: type de groupe - rain, flowrate, waterdepth
+        :param time: type de série - 5min, 5or10min, 1h, 1d, 1m
+        """
 
         if self.url!='':
             stations=None
@@ -406,21 +570,31 @@ class hydrometry():
 
             return stations
 
-    def get_sites(self):
-        """Obtention des sites pour le serveur courant"""
-        if self.dir!='' and exists(join(self.dir,'sites.csv')):
+    def get_sites(self, forcerequest=False):
+        """Obtention des sites pour le serveur courant
+
+        :param forcerequest: force la requête même si les données de cache sont déjà présentes"""
+
+        if self.dir!='' and exists(join(self.dir,'sites.csv')) and not forcerequest:
             self.sites = pd.read_csv(join(self.dir,'sites.csv'),index_col=0)
-        elif self.url!='':
+        elif self.url!='' or forcerequest:
             json_data = requests.get(self._get_commandstr(kiwis_command.getSiteList),verify=True, headers=self._header).json()
             self.sites = pd.DataFrame(json_data[1:], columns = json_data[0])
+        else:
+            self.sites = None
+
+    def get_groups(self, forcerequest=False):
+        """Obtention des groupes pour le serveur courant
 
-    def get_groups(self):
-        """Obtention des groupes pour le serveur courant"""
-        if self.dir!='' and exists(join(self.dir,'groups.csv')):
+        :param forcerequest: force la requête même si les données de cache sont déjà présentes"""
+
+        if self.dir!='' and exists(join(self.dir,'groups.csv')) and not forcerequest:
             self.groups = pd.read_csv(join(self.dir,'groups.csv'),index_col=0)
-        elif self.url!='':
+        elif self.url!='' or forcerequest:
             json_data = requests.get(self._get_commandstr(kiwis_command.getGroupList),verify=True, headers=self._header).json()
             self.groups = pd.DataFrame(json_data[1:], columns = json_data[0])
+        else:
+            self.groups = None
 
     # def get_ratingcurves(self):
     #     """Obtention des courbes de tarage pour le serveur courant"""
@@ -430,15 +604,24 @@ class hydrometry():
     #         json_data = requests.get(self.url+'?request=getRatingCurveList&datasource=0&format=json',verify=True).json()
     #         self.ratingcurves = pd.DataFrame(json_data[1:], columns = json_data[0])
 
-    def get_requests(self):
-        """Obtention des requêtes possibles pour le serveur courant"""
-        if self.dir!='' and exists(join(self.dir,'requests.csv')):
+    def get_requests(self, forcerequest=False):
+        """Obtention des requêtes possibles pour le serveur courant
+
+        :param forcerequest: force la requête même si les données de cache sont déjà présentes"""
+
+        if self.dir!='' and exists(join(self.dir,'requests.csv')) and not forcerequest:
             self.requests = pd.read_csv(join(self.dir,'requests.csv'),index_col=0)
-        elif self.url!='':
+        elif self.url!='' or forcerequest:
             json_data = requests.get(self._get_commandstr(kiwis_command.getrequestinfo),verify=True, headers=self._header).json()
             self.requests = pd.DataFrame(json_data[0]['Requests'])
+        else:
+            self.requests = None
+
+    def print_requestinfo(self, which:kiwis_command):
+        """ Affichage des informations pour une requête donnée
+
+        :param which: requête à afficher"""
 
-    def print_requestinfo(self,which:Enum):
         if self.requests is None:
             self.get_requests()
 
@@ -448,8 +631,13 @@ class hydrometry():
             for cur in kiwis_request_info:
                 print(myrequest[cur.value])
 
-    def timeseries_list(self,stationname='',stationcode=''):
-        """Récupération de la liste des TimeSeries pour l'id d'une station"""
+    def timeseries_list(self, stationname:str = '', stationcode:str = ''):
+        """Récupération de la liste des TimeSeries pour l'id d'une station
+        soit via le nom de la station, soit via le code de la station.
+
+        :param stationname: nom de la station
+        :param stationcode: code de la station
+        """
 
         if stationname!='':
             id=self.get_stationid(stationname)
@@ -463,12 +651,15 @@ class hydrometry():
 
         return id,pd.DataFrame(json_data[1:], columns = json_data[0])
 
-    def save_all_lists(self,dir):
-        """Sauveragde des listes pour toutes les stations"""
-        for curstation in self.stations['station_no']:
-            self.save_list(stationcode=curstation,dir=dir)
+    def save_all_lists(self, dir:str):
+        """Sauveragde des listes pour toutes les stations
+
+        :param dir: répertoire de sauvegarde"""
 
-    def _get_filename_list(self,stationname='',stationcode=''):
+        for curstation in self.stations[station_fields.STATION_NO.value]:
+            self.save_list(stationcode=curstation, dir=dir)
+
+    def _get_filename_list(self, stationname:str='', stationcode:str=''):
         """retourne un nom de fichier avec la station et le code
 
         Utile car dans certains noms de la BDD KIWIS il y a un caractère '/' qui ne peut être utilisé comme nom de fichier
@@ -484,7 +675,8 @@ class hydrometry():
 
         return stationname.replace('/','-') + '_' + stationcode + '_' + str(id) + '.csv'
 
-    def _get_filename_series(self,stationname='',stationcode='',which:Enum=kiwis_default_q.Q_FULL):
+    def _get_filename_series(self,stationname:str='',stationcode:str='',
+                             which:kiwis_default_q | kiwis_default_h | kiwis_keywords_horq | kiwis_keywords_rain = kiwis_default_q.Q_FULL):
         """retourne un nom de fichier avec la station et le code et le type de données
 
         Utile car dans certains noms de la BDD KIWIS il y a un caractère '/' qui ne peut être utilisé comme nom de fichier
@@ -500,16 +692,24 @@ class hydrometry():
 
         return stationname.replace('/','-') + '_' + stationcode + '_' + str(id) + '_' + which.value + '.csv'
 
-    def save_list(self,stationname='',stationcode='',dir=''):
-        """Sauvegarde de la liste des des timeseries dans un fichier"""
-        if not exists(dir):
-            mkdir(dir)
+    def save_list(self, stationname:str = '', stationcode:str = '', dir:str = ''):
+        """Sauvegarde de la liste des des timeseries dans un fichier
+
+        :param stationname: nom de la station
+        :param stationcode: code de la station
+        :param dir: répertoire de sauvegarde"""
+
+        dir = Path(dir)
+        if not dir.exists():
+            dir.mkdir(parents=True, exist_ok=True)
 
         id,list=self.timeseries_list(stationname=stationname,stationcode=stationcode)
         filename = self._get_filename_list(stationname,stationcode)
-        list.to_csv(join(dir,filename))
+        list.to_csv(dir / filename)
 
-    def timeseries(self,stationname='', stationcode='', dir='', fromdate=datetime.now()-timedelta(60), todate=datetime.now(), ts_name:str='', ts_id:str='', interval=3600, timezone = 'GMT+0'):
+    def timeseries(self,stationname:str='', stationcode:str='', dir:str='',
+                   fromdate=datetime.now()-timedelta(60), todate=datetime.now(),
+                   ts_name:str='', ts_id:str='', interval:int=3600, timezone:str = 'GMT+0'):
         """
         Récupération des valeurs d'une TimeSerie
           - sur base des dates
@@ -517,6 +717,16 @@ class hydrometry():
             - le nom de la station ou le code ET le nom de la timeserie --> dans ce cas, la routine commence par retrouver l'id de la ts
             - directement l'id de la timeserie
 
+        :param stationname: nom de la station
+        :param stationcode: code de la station
+        :param dir: répertoire de sauvegarde
+        :param fromdate: date de début
+        :param todate: date de fin
+        :param ts_name: nom de la timeserie
+        :param ts_id: id de la timeserie
+        :param interval: intervalle de temps
+        :param timezone: timezone
+
         """
 
         if timezone=='Europe/Brussels' or timezone=='local':
@@ -542,11 +752,11 @@ class hydrometry():
                 if len(json_data)==1:
                     return None
 
-                ts_id = str(int(pd.DataFrame(json_data[1:], columns = json_data[0])['ts_id'].iloc[0]))
+                ts_id = str(int(pd.DataFrame(json_data[1:], columns = json_data[0])[timeseries_fields.TS_ID.value].iloc[0]))
             else:
                 filename = self._get_filename_list(stationname,stationcode)
                 curlist=pd.read_csv(join(dir,filename),index_col=0)
-                ts_id = str(int(curlist.loc(curlist['ts_name'==ts_name])['ts_id']))
+                ts_id = str(int(curlist.loc(curlist[timeseries_fields.TS_NAME.value==ts_name])[timeseries_fields.TS_ID.value]))
 
             if "1h" in ts_name:
                 nb = (todate - fromdate).days*24
@@ -573,7 +783,10 @@ class hydrometry():
             locts=[]
             while curfrom<todate:
                 print(curfrom, curend)
-                locts.append(self.timeseries(stationname, stationcode, dir, curfrom, curend, ts_name, ts_id, timezone=timezone))
+                tmpts = self.timeseries(stationname, stationcode, dir, curfrom, curend, ts_name, ts_id, timezone=timezone)
+                if len(tmpts)>0:
+                    locts.append(tmpts)
+
                 curfrom = curend
                 curend = curfrom+timedelta(seconds=200000 * cursec)
                 if curend>todate:
@@ -596,7 +809,9 @@ class hydrometry():
 
         return df.squeeze()
 
-    def timeseries_qc(self,stationname='', stationcode='', dir='', fromdate=datetime.now()-timedelta(60), todate=datetime.now(), ts_name:str='', ts_id:str='', interval=3600, timezone = 'GMT+0'):
+    def timeseries_qc(self, stationname:str='', stationcode:str='', dir:str='',
+                      fromdate=datetime.now()-timedelta(60), todate=datetime.now(),
+                      ts_name:str='', ts_id:str='', interval:int=3600, timezone:str = 'GMT+0'):
         """
         Récupération des quality code d'une TimeSerie
           - sur base des dates
@@ -604,6 +819,16 @@ class hydrometry():
             - le nom de la station ou le code ET le nom de la timeserie --> dans ce cas, la routine commence par retrouver l'id de la ts
             - directement l'id de la timeserie
 
+        :param stationname: nom de la station
+        :param stationcode: code de la station
+        :param dir: répertoire de sauvegarde
+        :param fromdate: date de début
+        :param todate: date de fin
+        :param ts_name: nom de la timeserie
+        :param ts_id: id de la timeserie
+        :param interval: intervalle de temps
+        :param timezone: timezone
+
         """
         if timezone=='Europe/Brussels' or timezone=='local':
             timezone=''
@@ -629,11 +854,11 @@ class hydrometry():
                 if len(json_data)==1:
                     return None
 
-                ts_id = str(int(pd.DataFrame(json_data[1:], columns = json_data[0])['ts_id'].iloc[0]))
+                ts_id = str(int(pd.DataFrame(json_data[1:], columns = json_data[0])[timeseries_fields.TS_ID.value].iloc[0]))
             else:
                 filename = self._get_filename_list(stationname,stationcode)
                 curlist=pd.read_csv(join(dir,filename),index_col=0)
-                ts_id = str(int(curlist.loc(curlist['ts_name'==ts_name])['ts_id']))
+                ts_id = str(int(curlist.loc(curlist[timeseries_fields.TS_NAME.value==ts_name])[timeseries_fields.TS_ID.value]))
 
             if "1h" in ts_name:
                 nb = (todate - fromdate).days*24
@@ -683,14 +908,27 @@ class hydrometry():
 
         return df.squeeze()
 
-    def fromcsv(self,dir='spw',stationname='',stationcode='',which:Enum=kiwis_default_q.Q_FULL,fromdate:datetime=None,todate:datetime=None):
+    def fromcsv(self, dir:str='spw', stationname:str='', stationcode:str='',
+                which:kiwis_default_q | kiwis_default_h | kiwis_keywords_horq | kiwis_keywords_rain = kiwis_default_q.Q_FULL,
+                fromdate:datetime=None, todate:datetime=None):
         """
-        Lecture depuis un fichier csv créé depuis un import précédent
-        Les fichiers doivent être disponibles depuis un sous-répertoire spw
+        Lecture depuis un fichier csv créé depuis un import précédent.
+        Les fichiers doivent être disponibles depuis un sous-répertoire spw.
+
+        :param dir: répertoire de sauvegarde
+        :param stationname: nom de la station
+        :param stationcode: code de la station
+        :param which: type de données
+        :param fromdate: date de début
+        :param todate: date de fin
+
         """
-        filename=filename=self._get_filename_series(stationname,stationcode,which)
+        filename=self._get_filename_series(stationname,stationcode,which)
+
+        dir = Path(dir)
+        filename = dir / filename
 
-        if exists(filename):
+        if filename.exists():
             mydata= pd.read_csv(filename,header=0,index_col=0,parse_dates=True,engine='pyarrow').squeeze("columns")
         else:
             return
@@ -704,88 +942,134 @@ class hydrometry():
         else:
             return mydata[fromdate:todate]
 
-    def saveas(self,flow:pd.Series,dir:str,stationname='',stationcode='',which:Enum=kiwis_default_q.Q_FULL):
-        """Sauvegarde d'une series pandas dans un fichier .csv"""
+    def saveas(self, flow:pd.Series, dir:str, stationname='', stationcode='',
+               which:kiwis_default_q | kiwis_default_h | kiwis_keywords_horq | kiwis_keywords_rain = kiwis_default_q.Q_FULL):
+        """Sauvegarde d'une series pandas dans un fichier .csv
+
+        :param flow: série pandas
+        :param dir: répertoire de sauvegarde
+        :param stationname: nom de la station
+        :param stationcode: code de la station
+        :param which: type de données
+        """
+
         filename=self._get_filename_series(stationname,stationcode,which.value)
+
+        dir = Path(dir)
+        filename = dir / filename
+
         flow.to_csv(filename,header=['Data'], date_format="%Y-%m-%dT%H:%M:%S.%f%z")
 
-    def get_stationid(self,name:str='',code=''):
-        """Récupération de l'id sur base du nom ou du code"""
+    def get_stationid(self, name:str='', code:str='') -> int:
+        """Récupération de l'id sur base du nom ou du code
+
+        :param name: nom de la station
+        :param code: code de la station"""
+
         if name!='':
-            return int(self.stations.loc[self.stations['station_name']==name.lower()]['station_id'].iloc[0])
+            return int(self.stations.loc[self.stations[station_fields.STATION_NAME.value]==name.lower()][station_fields.STATION_ID.value].iloc[0])
         elif code!='':
-            return int(self.stations.loc[self.stations['station_no']==code]['station_id'].iloc[0])
+            return int(self.stations.loc[self.stations[station_fields.STATION_NO.value]==code][station_fields.STATION_ID.value].iloc[0])
         else:
             return None
 
-    def get_gauge_datum(self,name:str='',code=''):
-        """Récupération de l'altitude de référence sur base du nom ou du code"""
+    def get_gauge_datum(self,name:str='',code:str=''):
+        """Récupération de l'altitude de référence sur base du nom ou du code
+
+        :param name: nom de la station
+        :param code: code de la station"""
+
         try:
             if name!='':
-                return self.stations.loc[self.stations['station_name']==name.lower()]['station_gauge_datum'].iloc[0]
+                return self.stations.loc[self.stations[station_fields.STATION_NAME.value]==name.lower()]['station_gauge_datum'].iloc[0]
             elif code!='':
-                return self.stations.loc[self.stations['station_no']==code]['station_gauge_datum'].iloc[0]
+                return self.stations.loc[self.stations[station_fields.STATION_NO.value]==code]['station_gauge_datum'].iloc[0]
             else:
                 return None
         except:
             return None
 
-    def get_catchment_size(self,name:str='',code=''):
-        """Récupération de la surface du BV de référence sur base du nom ou du code"""
+    def get_catchment_size(self,name:str='',code:str=''):
+        """Récupération de la surface du BV de référence sur base du nom ou du code
+
+        :param name: nom de la station
+        :param code: code de la station"""
+
         try:
             if name!='':
-                return self.stations.loc[self.stations['station_name']==name.lower()]['CATCHMENT_SIZE'].iloc[0]
+                return self.stations.loc[self.stations[station_fields.STATION_NAME.value]==name.lower()]['CATCHMENT_SIZE'].iloc[0]
             elif code!='':
-                return self.stations.loc[self.stations['station_no']==code]['CATCHMENT_SIZE'].iloc[0]
+                return self.stations.loc[self.stations[station_fields.STATION_NO.value]==code]['CATCHMENT_SIZE'].iloc[0]
             else:
                 return None
         except:
             return None
 
-    def get_bv_dce(self,name:str='',code=''):
-        """Récupération du nom de BV au sens de la DCE "Directive Cadre Eau" sur base du nom ou du code"""
+    def get_bv_dce(self,name:str='',code:str=''):
+        """Récupération du nom de BV au sens de la DCE "Directive Cadre Eau" sur base du nom ou du code
+
+        :param name: nom de la station
+        :param code: code de la station"""
+
         try:
             if name!='':
-                return self.stations.loc[self.stations['station_name']==name.lower()]['BV_DCE'].iloc[0]
+                return self.stations.loc[self.stations[station_fields.STATION_NAME.value]==name.lower()]['BV_DCE'].iloc[0]
             elif code!='':
-                return self.stations.loc[self.stations['station_no']==code]['BV_DCE'].iloc[0]
+                return self.stations.loc[self.stations[station_fields.STATION_NO.value]==code]['BV_DCE'].iloc[0]
             else:
                 return None
         except:
             return None
 
     def get_stationcode(self,name:str=''):
-        """Récupération du code sur base du nom"""
+        """Récupération du code sur base du nom
+
+        :param name: nom de la station
+        """
+
         if name!='':
-            return self.stations.loc[self.stations['station_name']==name.lower()]['station_no'].squeeze()
+            return self.stations.loc[self.stations[station_fields.STATION_NAME.value]==name.lower()][station_fields.STATION_NO.value].squeeze()
         else:
             return None
 
     def get_stationname(self,code:str=''):
-        """Récupération du nom sur base du code"""
+        """Récupération du nom sur base du code
+
+        :param code: code de la station"""
+
         if code!='':
-            return self.stations.loc[self.stations['station_no']==code]['station_name'].squeeze()
+            return self.stations.loc[self.stations[station_fields.STATION_NO.value]==code][station_fields.STATION_NAME.value].squeeze()
         else:
             return None
 
-    def get_siteid(self,name:str='',code=''):
-        """Récupération de l'id sur base du nom ou du code"""
+    def get_siteid(self,name:str='',code:str=''):
+        """Récupération de l'id sur base du nom ou du code
+
+        :param name: nom de la station
+        :param code: code de la station"""
+
         if name!='':
-            return int(self.sites.loc[self.sites[kiwis_site_fields.site_name.value]==name.lower()]['site_id'])
+            return int(self.sites.loc[self.sites[kiwis_site_fields.site_name.value]==name.lower()][kiwis_site_fields.site_id.value])
         elif code!='':
-            return int(self.sites.loc[self.sites[kiwis_site_fields.site_no.value]==code]['site_id'])
+            return int(self.sites.loc[self.sites[kiwis_site_fields.site_no.value]==code][kiwis_site_fields.site_id.value])
         else:
             return None
 
-    def get_sitecode(self,name:str=''):
-        """Récupération du code sur base du nom"""
+    def get_sitecode(self, name:str=''):
+        """Récupération du code sur base du nom
+
+        :param name: nom de la station"""
+
         if name!='':
             return self.sites.loc[self.sites[kiwis_site_fields.site_name.value]==name.lower()][kiwis_site_fields.site_no.value].squeeze()
         else:
             return None
 
     def get_sitename(self,code:str=''):
-        """Récupération du nom sur base du code"""
+        """Récupération du nom sur base du code
+
+        :param code: code de la station"""
+
         if code!='':
             return self.sites.loc[self.sites[kiwis_site_fields.site_no.value]==code][kiwis_site_fields.site_name.value].squeeze()
         else: