wolfhece 2.2.40__py3-none-any.whl → 2.2.42__py3-none-any.whl

wolfhece/eva/pyseries.py

@@ -1277,8 +1277,31 @@ class EVA_Serie:
             k+=1
 
 
-    def plot_classified_flowrate_curve(self, fig:Figure=None, ax:Axes=None, label='', textvalues=True, show=False) -> tuple[Figure,Axes]:
+    def plot_classified_flowrate_curve(self, fig:Figure=None, ax:Axes=None, label='', textvalues=True, show=False) -> tuple[Figure,Axes, dict]:
+        """
+        Plot classified flow rate curve.
+
+        Characteristics returned in dict are:
+            - DCE : Débit journalier dépassé en moyenne 355 jours par an
+            - DC10 : Débit journalier dépassé en moyenne 10 mois par an
+            - Q347 : Débit atteint ou dépassé, en moyenne, pendant 347 jours par an
+            - DM : Débit atteint ou dépassé, en moyenne, pendant 50% du temps - débit médian
+            - DCC : Débit journalier qui est dépassé 10 jours par an
+
+        Previous lines are keys of characteristics dict.
 
+        Each characteristic is a dict with:
+        - 'help' : explanation of characteristic
+        - 'x' : number of days with exceedance
+        - 'value' : discharge value
+
+        :param fig: Matplotlib figure
+        :param ax: Matplotlib axis
+        :param label: label for the curve
+        :param textvalues: if True, text of characteristics are added
+        :param show: if True, plt.show() is called
+        :return: fig, ax, resdict
+        """
         if ax is None:
             fig,ax = plt.subplots(1,1)
 

wolfhece/hydrometry/kiwis.py

@@ -1114,8 +1114,10 @@ class hydrometry():
             while curfrom<todate:
                 logging.info('Getting data from {0} to {1}'.format(curfrom, curend))
                 tmpts = self.timeseries(stationname, stationcode, dir = dir, fromdate= curfrom, todate= curend, ts_name= ts_name, ts_id= ts_id, timezone=timezone)
-                if len(tmpts)>0:
-                    locts.append(tmpts)
+
+                if isinstance(tmpts, pd.Series):
+                    if len(tmpts)>0:
+                        locts.append(tmpts)
 
                 curfrom = curend
                 curend = curfrom+timedelta(seconds=200000 * cursec)
@@ -1145,7 +1147,7 @@ class hydrometry():
                 df.index = pd.to_datetime(df.index,format="%Y-%m-%dT%H:%M:%S.%f%z")
 
             except Exception as e:
-                logging.error('Error in timeseries :', e)
+                logging.error('Error in timeseries ! - Check if the server is responding.')
                 return pd.DataFrame()
 
         return df.squeeze()

wolfhece/hydrometry/kiwis_gui.py

@@ -17,6 +17,7 @@ import matplotlib.pyplot as plt
 import pandas as pd
 from datetime import datetime as dt, timedelta
 import logging
+import numpy as np
 
 #Test de la présence de la fonction de traduction i18n "gettext" et définition le cas échéant pour ne pas créer d'erreur d'exécution
 import os
@@ -472,7 +473,7 @@ class hydrometry_gui(wx.Frame):
         for curdata, curname in zip(data,tsname):
             if curdata is not None:
                 if len(curdata)>1:
-                    if datumsizebv[0]!='':
+                    if datumsizebv[0]!='' and not np.isnan(datumsizebv[0]):
                         ax.step(curdata.index, curdata+float(datumsizebv[0]), where='post', label=curname)
                     else:
                         ax.step(curdata.index, curdata, where='post', label=curname)

wolfhece/math_parser/calculator.py

@@ -142,7 +142,7 @@ class Calculator(wx.Frame):
                                                        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)
+                    self._memory[id_array] = self._mapviewer.get_obj_from_id(id_array, drawing_type=draw_type.ARRAYS)
 
             if len(variables) > 0:
                 for var in variables:

wolfhece/mesh2d/wolf2dprev.py

@@ -51,6 +51,8 @@ PREV_INFILTRATION_VAR_SIMPLE = -1  #INFILTRATION VARIABLE (RÉPARTITION UNIFORME
 PREV_INFILTRATION_VAR_MOD_MOMENTUM = -2  #INFILTRATION VARIABLE AVEC MOD QT MVT (RÉPARTITION NON UNIFORME DU DÉBIT INJECTÉ CALCULÉ SUR BASE DE L'ÉTAT HYDRODYNAMIQUE INSTANTANÉ)
 PREV_INFILTRATION_VAR_LINKED_ZONES = -3  #INFILTRATION/EXFILTRATION "INTERNE" VARIABLE (RÉPARTITION UNIFORME DU DÉBIT SUR BASE DE DEUX ZONES D'INFILTRATION)
 
+PREV_INFILTRATION_MODES = [PREV_INFILTRATION_NULL, PREV_INFILTRATION_SIMPLE, PREV_INFILTRATION_MOD_MOMENTUM, PREV_INFILTRATION_MOD_MOMENTUM_IMPOSED, PREV_INFILTRATION_VAR_SIMPLE, PREV_INFILTRATION_VAR_MOD_MOMENTUM, PREV_INFILTRATION_VAR_LINKED_ZONES]
+
 ##
 PREV_READ_TXT = 1
 PREV_READ_FINE = 2
@@ -968,8 +970,8 @@ class prev_parameters_blocks:
     def get_params_sediment(self) -> dict:
         """ Retourne les paramètres du modèle sédimentaire """
 
-        return {_('Model'): self.get_params_sediment_model(),
-                _('Drifting model'): self.get_params_sediment_drifting_model(),
+        return {_('Model'): self._get_params_sediment_model(),
+                _('Drifting model'): self._get_params_sediment_drifting_model(),
                 _('Porosity'): self._sed_porosity,
                 _('Mean diameter'): self._sed_d_mean,
                 _('Sediment density'): self._sed_s,
@@ -2127,48 +2129,74 @@ class prev_parameters_blocks:
                     'cd_c': self._infil_dev_c,
                     'cd_d': self._infil_dev_d}
 
-        elif self._infiltration_mode == 4:
-            return self.get_infiltration_momentum_correction_params()
+        elif self._infiltration_mode == PREV_INFILTRATION_MOD_MOMENTUM_IMPOSED:
+            return self.get_params_infiltration_momentum_correction()
 
         else:
             return {}
 
+    def get_infiltration_mode(self) -> int:
+        """ Retourne le mode d'infiltration """
+        return self._infiltration_mode
+
+    def set_infiltration_mode(self, mode:int) -> None:
+        """ Définit le mode d'infiltration
+
+        0 : PREV_INFILTRATION_NULL  - PAS D'INFILTRATION
+        1 : PREV_INFILTRATION_SIMPLE - INFILTRATION SIMPLE (RÉPARTITION UNIFORME DU DÉBIT INJECTÉ PAR FICHIER .INF)
+        2 : PREV_INFILTRATION_MOD_MOMENTUM - INFILTRATION AVEC MODIFICATION DE LA QT DE MVT (RÉPARTITION NON UNIFORME DU DÉBIT INJECTÉ PAR FICHIER .INF)
+        4 : PREV_INFILTRATION_MOD_MOMENTUM_IMPOSED - INFILTRATION AVEC MODIFICATION IMPOSÉE DE LA QT DE MVT (RÉPARTITION NON UNIFORME DU DÉBIT INJECTÉ PAR FICHIER .INF)
+        -1 : PREV_INFILTRATION_VAR_SIMPLE - INFILTRATION VARIABLE (RÉPARTITION UNIFORME DU DÉBIT INJECTÉ CALCULÉ SUR BASE DE L'ÉTAT HYDRODYNAMIQUE INSTANTANÉ)
+        -2 : PREV_INFILTRATION_VAR_MOD_MOMENTUM - INFILTRATION VARIABLE AVEC MOD QT MVT (RÉPARTITION NON UNIFORME DU DÉBIT INJECTÉ CALCULÉ SUR BASE DE L'ÉTAT HYDRODYNAMIQUE INSTANTANÉ)
+        -3 : PREV_INFILTRATION_VAR_LINKED_ZONES - INFILTRATION/EXFILTRATION "INTERNE" VARIABLE (RÉPARTITION UNIFORME DU DÉBIT SUR BASE DE DEUX ZONES D'INFILTRATION)
+
+        :param mode: mode d'infiltration
+        """
+        assert isinstance(mode, int), "mode must be an integer"
+        assert mode in PREV_INFILTRATION_MODES, f"mode must be in {PREV_INFILTRATION_MODES}"
+        self._infiltration_mode = mode
+
+    def reset_infiltration_mode(self) -> None:
+        """ Réinitialise le mode d'infiltration """
+        self._infiltration_mode = PREV_INFILTRATION_NULL
+
+
     def check_params_infiltration(self) -> tuple[bool, str]:
         """ Vérifie les paramètres d'infiltration """
 
         ret = '\nInfiltration\n************\n'
         valid = True
 
-        if self._infiltration_mode == 0:
+        if self._infiltration_mode == PREV_INFILTRATION_NULL:
             ret += _('Info: No infiltration\n')
-        elif self._infiltration_mode == 1:
+        elif self._infiltration_mode == PREV_INFILTRATION_SIMPLE:
             ret += _('Info: Simple infiltration\n')
-        elif self._infiltration_mode == 2:
+        elif self._infiltration_mode == PREV_INFILTRATION_MOD_MOMENTUM:
             ret += _('Info: Infiltration with momentum modification\n')
-        elif self._infiltration_mode == 4:
+        elif self._infiltration_mode == PREV_INFILTRATION_MOD_MOMENTUM_IMPOSED:
             ret += _('Info: Infiltration with imposed momentum modification\n')
-        elif self._infiltration_mode == -1:
+        elif self._infiltration_mode == PREV_INFILTRATION_VAR_SIMPLE:
             ret += _('Info: Variable infiltration\n')
-        elif self._infiltration_mode == -2:
+        elif self._infiltration_mode == PREV_INFILTRATION_VAR_MOD_MOMENTUM:
             ret += _('Info: Variable infiltration with momentum modification\n')
-        elif self._infiltration_mode == -3:
+        elif self._infiltration_mode == PREV_INFILTRATION_VAR_LINKED_ZONES:
             ret += _('Info: Variable infiltration/exfiltration (linked zone)\n')
 
         if self._infiltration_mode < 0:
             ret += _('Info: Coefficients a={self._infil_a}, b={self._infil_b}, c={self._infil_c}\n')
 
-            if self._infiltration_mode != -3 and self._infil_a == 0. and self._infil_b == 0. and self._infil_c == 0.:
+            if self._infiltration_mode != PREV_INFILTRATION_VAR_LINKED_ZONES and self._infil_a == 0. and self._infil_b == 0. and self._infil_c == 0.:
                 ret += _('Warning: No polynomial infiltration\n')
 
-            if self._infiltration_mode == -3 and self._infil_a == 0.:
+            if self._infiltration_mode == PREV_INFILTRATION_VAR_LINKED_ZONES and self._infil_a == 0.:
                 ret += _('Warning: No infiltration/exfiltration under bridge\n')
 
             ret += _('Info: Coefficients Cd={self._infil_dev_cd}, width={self._infil_dev_width}\n, zseuil={self._infil_dev_zseuil}')
 
-            if self._infiltration_mode != -3 and self._infil_dev_cd == 0. or self._infil_dev_width == 0.:
+            if self._infiltration_mode != PREV_INFILTRATION_VAR_LINKED_ZONES and self._infil_dev_cd == 0. or self._infil_dev_width == 0.:
                 ret += _('Warning: No weir exfiltration\n')
 
-            if self._infiltration_mode == -3 and (self._infil_dev_cd == 0. or self._infil_dev_width == 0.):
+            if self._infiltration_mode == PREV_INFILTRATION_VAR_LINKED_ZONES and (self._infil_dev_cd == 0. or self._infil_dev_width == 0.):
                 ret += _('Warning: No weir over bridge\n')
 
             ret += _('Info: Coefficients d={self._infil_var_d}, e={self._infil_var_e}\n')
@@ -2195,7 +2223,7 @@ class prev_parameters_blocks:
         self._infil_correction_ux = ux
         self._infil_correction_vy = vy
 
-        if self._infiltration_mode != 4:
+        if self._infiltration_mode != PREV_INFILTRATION_MOD_MOMENTUM_IMPOSED:
             logging.warning("To apply, you must set ninfil to 4")
         else:
             logging.info("Infiltration momentum correction applied")
@@ -2203,7 +2231,7 @@ class prev_parameters_blocks:
     def get_params_infiltration_momentum_correction(self) -> dict:
         """ Retourne les corrections de moment pour l'infiltration """
 
-        if self._infiltration_mode == 4:
+        if self._infiltration_mode == PREV_INFILTRATION_MOD_MOMENTUM_IMPOSED:
             return {'ux': self._infil_correction_ux,
                     'vy': self._infil_correction_vy}
         else:

wolfhece/models/walous_ocs.pal

@@ -0,0 +1,49 @@
+12
+0.0
+229
+234
+63
+1.0
+138
+138
+138
+2.0
+220
+15
+15
+3.0
+78
+78
+78
+4.0
+208
+208
+208
+5.0
+36
+97
+247
+6.0
+255
+255
+115
+7.0
+233
+255
+190
+8.0
+0
+50
+0
+9.0
+40
+200
+40
+80.0
+0
+120
+0
+90.0
+183
+232
+176

wolfhece/pydownloader.py

@@ -19,6 +19,7 @@ from enum import Enum
 from typing import Union, Optional, List
 from collections import namedtuple
 import logging
+import urllib.parse
 
 class DownloadType(Enum):
     """ Enum to define the type of download. """
@@ -44,7 +45,7 @@ class DownloadFiles(Enum):
     DXFFILES = ('dxf',)
     ZIPFILES = ('zip',)
     LAZFILES = ('laz',)
-    GRIDWOLF = ('lst',)
+    LISTFILES = ('lst',)
     LAZBIN = ('bin',)
 
 class DonwloadDirectories(Enum):
@@ -54,6 +55,10 @@ class DonwloadDirectories(Enum):
 
 GITLAB_EXAMPLE = 'https://gitlab.uliege.be/HECE/wolf_examples/-/raw/main'
 GITLAB_EXAMPLE_GPU = 'https://gitlab.uliege.be/HECE/wolfgpu_examples/-/raw/main'
+
+GITLAB_MODREC_DATA_VESDRE = 'https://gitlab.uliege.be/api/v4/projects/4933'
+GITLAB_MODREC_DATA_VESDRE_FILES = 'https://gitlab.uliege.be/api/v4/projects/4933/repository/files/'
+
 DATADIR = Path(__file__).parent / 'data' / 'downloads'
 
 def clean_url(url: str) -> str:
@@ -83,7 +88,12 @@ def clean_url(url: str) -> str:
         raise ValueError(f"Invalid URL: {url}. Must start with http://, https://, or ftp://")
     return cleaned_url.strip()
 
-def download_file(url: str, destination: Union[str, Path] = None, download_type: DownloadType = DownloadType.HTTP, load_from_cache:bool = True):
+def download_file(url: str,
+                  destination: Union[str, Path] = None,
+                  download_type: DownloadType = DownloadType.HTTP,
+                  load_from_cache:bool = True,
+                  token:str = None,
+                  file_type:DownloadType = None) -> Path:
     """ Download a file from the specified URL to the destination path.
 
     :param url: The URL of the file to download.
@@ -98,11 +108,13 @@ def download_file(url: str, destination: Union[str, Path] = None, download_type:
 
     url = str(url).strip()
     # Clean the URL
-    url = clean_url(url)
+    if file_type is None:
+        url = clean_url(url)
 
     if destination is None:
         try:
-            destination = DATADIR / Path(url).parent.name / Path(url).name
+            url_cleaned = url.replace('/raw?ref=main', '').replace('%2F', '/')
+            destination = DATADIR / Path(url_cleaned).parent.name / Path(url_cleaned).name
         except:
             destination = DATADIR / Path(url).name
     # create the directory if it does not exist
@@ -113,16 +125,19 @@ def download_file(url: str, destination: Union[str, Path] = None, download_type:
     if suffix.startswith('.'):
         suffix = suffix[1:]
 
-    # Find the download type based on the URL suffix
-    for file_type_enum in DownloadFiles:
-        if suffix in file_type_enum.value:
+    if file_type is None:
+        # Find the download type based on the URL suffix
+        for file_type_enum in DownloadFiles:
+            if suffix in file_type_enum.value:
 
-            if suffix == 'bin' and '_xyz.bin' in url:
-                # special case for LAZ bin files
-                file_type_enum = DownloadFiles.LAZBIN
+                if suffix == 'bin' and '_xyz.bin' in url:
+                    # special case for LAZ bin files
+                    file_type_enum = DownloadFiles.LAZBIN
 
-            file_type = file_type_enum
-            break
+                file_type = file_type_enum
+                break
+    else:
+        suffix = file_type.value[0]
 
     # Create a list of files to download based on the download type
     # by replacing suffix in the url with the appropriate file extensions
@@ -132,6 +147,7 @@ def download_file(url: str, destination: Union[str, Path] = None, download_type:
         if ext.startswith('.'):
             ext = ext[1:]
         to_download.append(url.replace(suffix, f'{ext}'))
+
         to_destination.append(destination.with_suffix(f'.{ext}'))
 
 
@@ -139,6 +155,15 @@ def download_file(url: str, destination: Union[str, Path] = None, download_type:
 
         for url, destination in zip(to_download, to_destination):
 
+            if token is not None:
+                # Requête HTTP avec le token
+                headers = {
+                    "PRIVATE-TOKEN": token
+                }
+            else:
+                headers = {}
+
+
             if load_from_cache and destination.exists():
                 logging.info(f"File {destination} already exists. Skipping download.")
                 continue
@@ -147,7 +172,7 @@ def download_file(url: str, destination: Union[str, Path] = None, download_type:
                 raise ValueError(f"Invalid URL: {url}. Must start with http:// or https://")
 
             try:
-                response = requests.get(url)
+                response = requests.get(url, headers=headers)
                 response.raise_for_status()
                 with open(destination, 'wb') as file:
                     file.write(response.content)
@@ -287,7 +312,109 @@ def toys_laz_grid(dir:str, file:str, load_from_cache:bool = True):
 
     return DATADIR / dir
 
+def laz_grid_from_url(url:str, dir:str, file:str, load_from_cache:bool = True):
+    """ Download toy LAZ or GRIDWOLF files from an external URL.
+
+    :param url: The base URL where the files are located.
+    :param dir: The directory where the file will be saved.
+    :param file: The name of the file to download.
+    :type url: str
+    :type dir: str
+    :type file: str
+    :return: The path to the downloaded directory.
+    """
+    url = f"{url}/{dir}/{file}"
+    destination = DATADIR / dir / file
+    lst = download_file(url, destination, load_from_cache=load_from_cache)
+
+    if not Path(lst).exists():
+        raise FileNotFoundError(f"The file {lst} does not exist. -- Check the URL and file name.")
+
+    with open(lst, 'r') as f:
+        lines = f.read().splitlines()
+
+    for line in lines:
+        line = line.strip().replace('\\', '/')
+        if line:
+            url = f"{GITLAB_EXAMPLE}/{dir}/{line}"
+            destination = DATADIR / dir / line
+            download_file(url, destination, load_from_cache=load_from_cache)
+
+    return DATADIR / dir
+
+def check_status(url:str, token:str = None) -> bool:
+    """ Check the status of a URL.
+
+    :param url: The URL to check.
+    :param token: The private token for authentication (if required).
+    :type url: str
+    :type token: str
+    :return: True if the URL is accessible, False otherwise.
+    :rtype: bool
+    """
+    url = str(url).strip()
+    url = clean_url(url)
+
+    if not url.startswith(('http://', 'https://')):
+        raise ValueError(f"Invalid URL: {url}. Must start with http:// or https://")
+
+    try:
+        if token is not None:
+            headers = {
+                "PRIVATE-TOKEN": token
+            }
+        else:
+            headers = {}
+
+        response = requests.head(url, headers=headers)
+        return response.status_code == 200
+    except requests.RequestException as e:
+        logging.error(f"Error checking URL {url}: {e}")
+        return False
+
+def download_modrec_vesdre_file(directory:str, filename:str,
+                                token:str = None, load_from_cache:bool = True,
+                                file_type:DownloadFiles = None) -> Path:
+
+    """ Download a file from the ModRec Vesdre dataset.
+
+    :param directory: The directory where the file is located (relative to the repository root).
+    :param filename: The name of the file to download.
+    :param token: The private token for authentication (if required).
+    :param load_from_cache: If True, will not download the file if it already exists.
+    :type directory: str
+    :type filename: str
+    :type token: str
+    :type load_from_cache: bool
+    :return: The path to the downloaded file.
+    :rtype: Path
+    """
+
+    # Find the download type based on the URL suffix
+    if file_type is None:
+        suffix = Path(filename).suffix.lower().replace('.', '')
+
+        for file_type_enum in DownloadFiles:
+            if suffix in file_type_enum.value:
+
+                if suffix == 'bin' and '_xyz.bin' in filename:
+                    # special case for LAZ bin files
+                    file_type_enum = DownloadFiles.LAZBIN
+
+                file_type = file_type_enum
+                break
+
+    file_path_encoded = urllib.parse.quote_plus(directory + '/' + filename)
+    url = f"{GITLAB_MODREC_DATA_VESDRE_FILES}{file_path_encoded}/raw?ref=main"
+    destination = DATADIR / 'Vesdre' / file_path_encoded.replace('%2F', '/')
+    return download_file(url, destination, token=token, load_from_cache=load_from_cache, file_type=file_type)
+
 if __name__ == "__main__":
+    token = '' # Add your GitLab private token here if needed
+    dir = 'LAZ_Vesdre/2023/grids_flt32/237500_145500'
+    file_path = "237500_145500_237500_145000_xyz.bin"
+    print(download_modrec_vesdre_file(dir, file_path, token=token, load_from_cache=False))
+
     # Example usage
     print(download_file(r'https:\\gitlab.uliege.be\HECE\wolf_examples\-\raw\main\Extract_part_array\extraction.vec'))
     print(download_file('https://gitlab.uliege.be/HECE/wolf_examples/-/raw/main/Extract_part_array/extraction.vec'))