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

wolfhece/PyDraw.py

@@ -8500,8 +8500,8 @@ class WolfMapViewer(wx.Frame):
         #     \n \
         #     !! ACTIONs !!\n \
         #     N : sélection noeud par noeud de la matrice courante\n \
-        #     B : sélection par vecteur temporaire de la matrice courante\n \
-        #     V : sélection par vecteur activé de la matrice courante - zone intérieure\n \
+        #     b, B : sélection par vecteur de la matrice courante - zone intérieure\n \
+        #     v, V : sélection par vecteur de la matrice courante - trace du vecteur\n \
         #     r : reset de la sélection de la matrice courante\n \
         #     R : reset de toutes les sélections de la matrice courante\n \
         #     P : sélection de la section transversale par click souris\n \
@@ -8558,8 +8558,8 @@ class WolfMapViewer(wx.Frame):
                      'F11': _('Arrays : select by criteria'),
                      'F12': _('Arrays : operations'),
                      'n or N': _('Arrays : node-by-node selection'),
-                     'b or B': _('Arrays : temporary vector selection'),
-                     'v or V': _('Arrays : activated vector selection - inner zone'),
+                     'b or B': _('Arrays : temporary/active vector selection - inside polygon'),
+                     'v or V': _('Arrays : temporary/active vector selection - along polyline'),
 
                      'r': _('Arrays : reset the selection'),
                      'R': _('Arrays : reset the selection and the associated dictionnary'),
@@ -9011,6 +9011,12 @@ class WolfMapViewer(wx.Frame):
             elif key in LIST_1TO9:
 
                 if self.active_array is not None:
+
+                    if self.active_array.SelectionData.myselection == 'all':
+                        logging.warning(_('No selection to transfer to the dictionary !'))
+                        logging.info(_('Please select some nodes before transfering to the dictionary, not ALL !'))
+                        return
+
                     colors = [(0, 0, 255, 255), (0, 255, 0, 255), (0, 128, 255, 255), (255, 255, 0, 255), (255, 165, 0, 255), (128, 0, 128, 255), (255, 192, 203, 255), (165, 42, 42, 255), (128, 128, 128, 255)]
                     idx = LIST_1TO9.index(key)
                     if idx > 8:
@@ -9068,16 +9074,33 @@ class WolfMapViewer(wx.Frame):
                 if self.active_res2d is not None:
                     self.active_res2d.properties.select_node_by_node()
 
+                if self.active_array is None and self.active_res2d is None:
+                    logging.warning(_('No active array or result 2D to select node by node !'))
+
             elif key == ord('V'):  # V
                 if self.active_array is not None:
-                    self.active_array.myops.select_vector_inside_manager()
+                    if shiftdown:
+                        self.active_array.myops.select_vector_inside_manager()
+                    else:
+                        self.active_array.myops.select_vector_inside_tmp()
+                else:
+                    logging.warning(_('No active array to select the vector inside !'))
 
             elif key == ord('B'):  # B
                 if self.active_array is not None:
-                    self.active_array.myops.select_vector_inside_tmp()
+                    if shiftdown:
+                        self.active_array.myops.select_vector_under_manager()
+                    else:
+                        self.active_array.myops.select_vector_under_tmp()
+                else:
+                    logging.warning(_('No active array to select the vector inside !'))
 
             elif key == ord('P'):  # P
-                self.start_action('Select nearest profile', _('Select nearest profile'))
+
+                if self.active_cs is not None:
+                    self.start_action('Select nearest profile', _('Select nearest profile'))
+                else:
+                    logging.warning(_('No active cross section to select the nearest profile !'))
 
             elif key == ord('Z') and shiftdown:  # Z
                 self.width = self.width / 1.1

wolfhece/apps/version.py

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

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:

wolfhece/math_parser/calculator.py

@@ -10,14 +10,15 @@ copying or distribution of this file, via any medium, is strictly prohibited.
 
 import wx
 import logging
+from pathlib import Path
 
 
 from . import Parser, Expression
 
 class Calculator(wx.Frame):
- 
+
     def __init__(self, mapviewer=None):
-        
+
         from ..PyDraw import WolfMapViewer, draw_type, WolfArray
 
         super(Calculator, self).__init__(None, title='Calculator', size=(500, 300))
@@ -38,18 +39,23 @@ class Calculator(wx.Frame):
         self._comment = wx.TextCtrl(self, style=wx.TE_RIGHT|wx.TE_RICH2|wx.TE_MULTILINE)
         self.memory   = wx.TextCtrl(self, style=wx.TE_RIGHT|wx.TE_RICH2|wx.TE_MULTILINE)
         self.btn_reset_memory = wx.Button(self, label='Reset Memory')
-        
+
         self.Bind(wx.EVT_BUTTON, lambda v: self.bt_press(v.EventObject.Label))
 
-        self._btns[-1][-2].SetDefault() 
+        self._btns[-1][-2].SetDefault()
 
         self.Bind(wx.EVT_CHAR_HOOK, self.char_press)
         self.btn_reset_memory.Bind(wx.EVT_BUTTON, lambda v: self._memory.clear())
-        
+
         self.SetSizer(self.pack([self._disp] + [self.pack(x) for x in self._btns] + [self.pack([self._comment, self.btn_reset_memory, self.memory])], orient=wx.VERTICAL))
 
         self._disp.SetFocus()
 
+        icon = wx.Icon()
+        icon_path = Path(__file__).parent.parent / "apps/wolf_logo2.bmp"
+        icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
+        self.SetIcon(icon)
+
         self.Show()
 
     def pack(self, items, orient=wx.HORIZONTAL):
@@ -57,11 +63,11 @@ class Calculator(wx.Frame):
         sizer = wx.BoxSizer(orient)
         sizer.AddMany((i, 1, wx.EXPAND|wx.ALL, 0) for i in items)
         return sizer
-    
+
     @property
     def command(self) -> str:
-        return self._disp.Value  
-    
+        return self._disp.Value
+
     @command.setter
     def command(self, value):
         self._disp.Value = str(value)
@@ -70,16 +76,16 @@ class Calculator(wx.Frame):
     @property
     def comment(self) -> str:
         return self._comment.Value
-    
+
     @comment.setter
     def comment(self, value):
         self._comment.Value = str(value)
 
     def check_command(self) -> bool:
-        """ Check if the command is valid """        
-        
+        """ Check if the command is valid """
+
         from ..PyDraw import draw_type
-        
+
         if '\n' in self.command:
             self.evaluate_multilines()
             return False
@@ -94,7 +100,7 @@ class Calculator(wx.Frame):
             if self._mapviewer is not None:
                 id_arrays = self._mapviewer.get_list_keys(drawing_type=draw_type.ARRAYS,
                                                        checked_state=None)
-                
+
                 for id_array in id_arrays:
                     self._memory[id_array] = self._mapviewer.get_obj_from_id(id_array, drawtype=draw_type.ARRAYS)
 
@@ -124,27 +130,27 @@ class Calculator(wx.Frame):
     def evaluate(self, mem_last_command=True):
         """ Evaluate the command """
         from ..PyDraw import WolfArray, draw_type
-        
+
         if mem_last_command:
             self._last_command = self.command
 
         ret = self.check_command()
-        
+
         if ret:
             args = {var:self._memory[var] for var in self._parsed_command.variables()}
             res = self._parsed_command.evaluate(args)
 
             if isinstance(res, dict):
-                
+
                 comment = 'Storing\n'
-                
+
                 for key, value in res.items():
                     self._memory[key] = value
                     comment += f'{key} = {value}\n'
-                
+
                 self.comment = comment
                 self.command = ''
-            
+
             elif isinstance(res, str|int|float):
                 self.command = res
 
@@ -154,10 +160,10 @@ class Calculator(wx.Frame):
                 id = self.command
                 while id in ids:
                     id += '_'
-                
+
                 self._mapviewer.add_object('array', newobj=res, id = id)
                 self.command = ''
-                
+
             return res
 
     def char_press(self, e:wx.KeyEvent):
@@ -168,13 +174,13 @@ class Calculator(wx.Frame):
 
         unicodekey = e.GetUnicodeKey()
         key = e.GetKeyCode()
- 
+
         ctrl = e.ControlDown()
         alt  = e.AltDown()
         shift= e.ShiftDown()
 
         if unicodekey in egal_code:
-            if not shift : 
+            if not shift :
                 self.evaluate()
                 return
 
@@ -186,4 +192,3 @@ class Calculator(wx.Frame):
         elif key == '<': self.command =self._last_command
         elif key == '=': self.evaluate()
         else           : self._disp.Value += key
- 

wolfhece/wolf_array.py

@@ -2503,6 +2503,8 @@ class Ops_Array(wx.Frame):
             logging.warning(_('Please add points to vector or select another !'))
             return
 
+        logging.info(_('Select nodes inside the active polygon/vector...'))
+
         self._select_vector_inside_manager(self.active_vector)
         self.refresh_array()
 
@@ -2528,9 +2530,11 @@ class Ops_Array(wx.Frame):
         """ Select nodes along the active zone (manager) """
 
         if self.active_zone is None:
-            wx.MessageBox('Please select an active zone !')
+            logging.warning(_('Please activate a zone !'))
             return
 
+        logging.info(_('Select nodes along the active zone - all polylines...'))
+
         for curvec in self.active_zone.myvectors:
             self._select_vector_under_manager(curvec)
 
@@ -2539,9 +2543,11 @@ class Ops_Array(wx.Frame):
     def select_vector_under_manager(self):
         """ Select nodes along the active vector (manager) """
         if self.active_vector is None:
-            wx.MessageBox('Please select an active vector !')
+            logging.warning(_('Please activate a vector !'))
             return
 
+        logging.info(_('Select nodes along the active polyline/vector...'))
+
         self._select_vector_under_manager(self.active_vector)
         self.refresh_array()
 
@@ -2567,6 +2573,7 @@ class Ops_Array(wx.Frame):
         """ Select nodes inside the temporary vector """
 
         if self.mapviewer is not None:
+            logging.info(_('Select nodes inside a temporary polygon/vector...'))
             logging.info(_('Please add points to vector by clicks !'))
 
             self.mapviewer.start_action('select by tmp vector inside', _('Please draw a polygon...'))
@@ -2581,9 +2588,9 @@ class Ops_Array(wx.Frame):
     def select_vector_under_tmp(self):
         """ Select nodes along the temporary vector """
         if self.mapviewer is not None:
+            logging.info(_('Select nodes along a temporary polygon/vector...'))
             logging.info(_('Please add points to vector by clicks !'))
 
-
             self.mapviewer.start_action('select by tmp vector along', _('Please draw a polyline...'))
             self.vectmp.reset()
             self.Active_vector(self.vectmp)
@@ -3272,6 +3279,10 @@ class SelectionData():
         myvect.find_minmax()
         mypoints = self.parent.get_ij_under_polyline(myvect)
 
+        if len(mypoints) == 0:
+            logging.info(_('No nodes under the polyline'))
+            return
+
         self._add_nodes_to_selectionij(mypoints, verif=nbini != 0)
 
         if self.parent.myops is not None:
@@ -6784,6 +6795,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         allij = np.unique(allij, axis=0)
 
+        # filter negative indexes
+        allij = allij[np.where((allij[:, 0] >= 0) & (allij[:, 1] >= 0) & (allij[:, 0] < self.nbx) & (allij[:, 1] < self.nby))]
+
         if usemask:
             mymask = np.logical_not(self.array.mask[allij[:, 0], allij[:, 1]])
             allij = allij[np.where(mymask)]

{wolfhece-2.1.66.dist-info → wolfhece-2.1.67.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.66
+Version: 2.1.67
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.1.66.dist-info → wolfhece-2.1.67.dist-info}/RECORD

@@ -7,7 +7,7 @@ wolfhece/ManageParams.py,sha256=EeuUI5Vvh9ixCvYf8YShMC1s1Yacc7OxOCN7q81gqiQ,517
 wolfhece/Model1D.py,sha256=uL1DJVmDI2xVSE7H6n3icn3QbsPtTHeg8E-6wkDloKw,476914
 wolfhece/PyConfig.py,sha256=FB8u0belXOXTb03Ln6RdVWvMgjzi3oGPCmw2dWa3lNg,8332
 wolfhece/PyCrosssections.py,sha256=FnmM9DWY_SAF2EDH9Gu2PojXNtSTRF4-aYQuAAJXBh4,112771
-wolfhece/PyDraw.py,sha256=pvvPOhMs1JxyYzEBPwBm7w5oP-0smiZly0pU4mv7LJY,409909
+wolfhece/PyDraw.py,sha256=yHbr9KolS2j0uL9wbzV6McwXvZHVeSSZ64y6-wJot5s,411135
 wolfhece/PyGui.py,sha256=oBIBpgBQRR_XXucKE5-RFrtqKj0DRg9VlUCRo8Mzalc,105009
 wolfhece/PyGuiHydrology.py,sha256=f60E8K9eGTnRq5RDF6yvt-ahf2AYegwQ9t25zZ2Mk1A,14946
 wolfhece/PyHydrographs.py,sha256=jwtSNMMACwarxrtN1UeQYth99UNrhwPx1IGgUwcooHA,3774
@@ -48,7 +48,7 @@ wolfhece/pywalous.py,sha256=yRaWJjKckXef1d9D5devP0yFHC9uc6kRV4G5x9PNq9k,18972
 wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=Zb93bxUx5JJ8Mq7jQWBMMRAJLsgSjeX5EIA31aJJ8LI,376066
+wolfhece/wolf_array.py,sha256=QmAcZNRMdGwqXRO3MsRMREYW_3ZdJ41i9gg4WMtAbLM,376746
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
 wolfhece/wolf_texture.py,sha256=DS5eobLxrq9ljyebYfpMSQPn8shkUAZZVfqrOKN_QUU,16951
 wolfhece/wolf_tiles.py,sha256=2Ho2I20rHRY81KXxjgLOYISdF4OkJ2d6omeY4shDoGI,10386
@@ -72,7 +72,7 @@ wolfhece/apps/check_install.py,sha256=Xoi_d8MzKzNAy2xqEpERdsqgRPu0hbBWukI0WkIYzD
 wolfhece/apps/curvedigitizer.py,sha256=Yps4bcayzbsz0AoVc_dkSk35dEhhn_esIBy1Ziefgmk,5334
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=SrustmIQeXnsiD-92OzjdGhBi-S7c_j-cSvuX4T6rtg,2929
-wolfhece/apps/version.py,sha256=O8ZZomRXgXIg3ep7c52RJmvZUQl3rFlDBMhUIg4HaA4,388
+wolfhece/apps/version.py,sha256=cRc1I581AOhBuOpRqqnB83bANUXPq9N2wF1OVKOBfno,388
 wolfhece/apps/wolf.py,sha256=j_CgvsL8rwixbVvVD5Z0s7m7cHZ86gmFLojKGuetMls,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -126,7 +126,7 @@ wolfhece/hydrology/read.py,sha256=itMat6MMn4Y14C3SMU_9JMBtpXFjG4mLNMfXXd5U6Ns,93
 wolfhece/hydrology/slope_manager.py,sha256=vlek0z8qcqB61eleiksyOe3QR1vpbtwfeowy6ms7_Fg,5580
 wolfhece/hydrology/wolfMap_treatment.py,sha256=eAxr24zJGwmDof1aZpcxewVvv_bWDvoO8t9Wwf99Mlo,10606
 wolfhece/hydrometry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wolfhece/hydrometry/kiwis.py,sha256=KHRfYrtd5hwxKxdChbkTXYH-cDSDcaQJFTEgjrnVMg4,34929
+wolfhece/hydrometry/kiwis.py,sha256=m3LGNxmB_ZY_ug-8BCM8jK_VqN6LtWRGpbPWtgRYFSE,46460
 wolfhece/hydrometry/kiwis_gui.py,sha256=lApsSeBMJNAR1yocggdoHwz_xe6M_oaZ_E13CfHAlQA,23124
 wolfhece/hydrometry/kiwis_wolfgui.py,sha256=GPa5YNp2V2ZlxYQjPiCXERgPuWB_zij4ec2yHpRvoFA,4027
 wolfhece/hydrometry/kiwispie.py,sha256=akOaV46WwzISVlCcPz_phjsBrI_rDACUzdELtjx-xNg,13498
@@ -213,7 +213,7 @@ wolfhece/mar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/mar/commontools.py,sha256=vCmoNI2sMOco6Y4KPpKb7WORq45qFU_lSxbKGV9oZ8A,53824
 wolfhece/mar/interface_MAR_WOLF.py,sha256=MWeXaHLDT4Eo9jZOAvz013lmpgGYT1v9VUYGAgBgSRU,21454
 wolfhece/math_parser/__init__.py,sha256=mrD_uFDDZzvyxQkY8ESqcy1bvM7e3__Gi2b_vijvoo8,27977
-wolfhece/math_parser/calculator.py,sha256=5VLYWkyvH7u3yMyQpzgc2uNyjgJHoS9HgLDyl6JqG38,6005
+wolfhece/math_parser/calculator.py,sha256=VCXCT5zhyMSgkO5O8dwIhRht9NNBqA0h1QPliOD4N28,6046
 wolfhece/mesh2d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/mesh2d/bc_manager.py,sha256=QTGkb5TR8Y5xVnGUXPXzscGyTEQ6PA8CZPkVNwrlR1Y,53265
 wolfhece/mesh2d/cell_tracker.py,sha256=mPmnD5lEf3gLPuLqtAIo-Gp-ipAwQdPxzjWOGt0b7jM,8958
@@ -283,8 +283,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.1.66.dist-info/METADATA,sha256=0sC8b4E0or7Irtp909AReOyaA-51BqdzyVnXFochOoo,2570
-wolfhece-2.1.66.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-wolfhece-2.1.66.dist-info/entry_points.txt,sha256=Q5JuIWV4odeIJI3qc6fV9MwRoz0ezqPVlFC1Ppm_vdQ,395
-wolfhece-2.1.66.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.66.dist-info/RECORD,,
+wolfhece-2.1.67.dist-info/METADATA,sha256=77W5WHquObr8qkk2A97PzjeORUnqfXAh_0Vo-F0cAaw,2570
+wolfhece-2.1.67.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+wolfhece-2.1.67.dist-info/entry_points.txt,sha256=Q5JuIWV4odeIJI3qc6fV9MwRoz0ezqPVlFC1Ppm_vdQ,395
+wolfhece-2.1.67.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.67.dist-info/RECORD,,