wolfhece 2.2.20__py3-none-any.whl → 2.2.24__py3-none-any.whl

wolfhece/_add_path.py

@@ -3,6 +3,11 @@ import os.path
 import sys
 import platform
 
+try:
+    import wolf_libs
+except ImportError:
+    print("wolf_libs not found. Please install the wolf-libs package -- pip install wolf-libs.")
+    sys.exit(1)
 
 def _add_path():
     _root_dir = os.path.dirname(os.path.realpath(__file__))
@@ -10,6 +15,10 @@ def _add_path():
     # manual specify list of dll directories, with paths relative to _root_dir
     _dll_dirs = ['libs', 'shaders']
 
+    # add wolf_libs path to __dll_dirs
+    if wolf_libs.__path__:
+        _dll_dirs.insert(0, os.path.join(wolf_libs.__path__[0]))
+
     if platform.system() == 'Windows':
         os.environ.setdefault('PATH', '')
         paths = os.environ['PATH'].split(';')

wolfhece/apps/check_install.py

@@ -8,6 +8,99 @@ Copyright (c) 2024 University of Liege. All rights reserved.
 This script and its content are protected by copyright law. Unauthorized
 copying or distribution of this file, via any medium, is strictly prohibited.
 """
+def test_conversion_LBT72_LBT08():
+
+    from pyproj.transformer import TransformerGroup
+
+    # Créer le groupe de transformateurs
+    tg = TransformerGroup(31370, 3812)
+
+    # Choisir le premier transformateur (ou un autre selon ton besoin)
+    transformer = tg.transformers[0]
+
+    print(transformer.description)
+    if '(3)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (3) + Belgian Lambert 2008
+        return True
+    elif '(2)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (2) + Belgian Lambert 2008
+        return False
+    elif '(1)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (1) + Belgian Lambert 2008
+        return False
+    else:
+        # This is not the expected transformer
+        return False
+
+def test_conversion_LBT08_LBT72():
+
+    from pyproj.transformer import TransformerGroup
+
+    # Créer le groupe de transformateurs
+    tg = TransformerGroup(3812, 31370)
+
+    # Choisir le premier transformateur (ou un autre selon ton besoin)
+    transformer = tg.transformers[0]
+
+    print(transformer.description)
+    if '(3)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (3) + Belgian Lambert 2008
+        return True
+    elif '(2)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (2) + Belgian Lambert 2008
+        return False
+    elif '(1)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (1) + Belgian Lambert 2008
+        return False
+    else:
+        # This is not the expected transformer
+        return False
+
+def test_transform_coordinates():
+    from pyproj.transformer import TransformerGroup
+    from pyproj import Transformer
+    import numpy as np
+    from wolfhece.Coordinates_operations import transform_coordinates
+    tg = TransformerGroup(31370, 3812)
+
+    ret = True
+
+    ret = ret and len(tg.transformers) > 0
+    ret = ret and len(tg.transformers) == 3
+    ret = ret and '(3)' in tg.transformers[0].description
+    ret = ret and '(2)' in tg.transformers[1].description
+    ret = ret and '(1)' in tg.transformers[2].description
+
+    tg_inv = TransformerGroup(3812, 31370)
+    ret = ret and len(tg_inv.transformers) > 0
+    ret = ret and len(tg_inv.transformers) == 3
+    ret = ret and '(3)' in tg_inv.transformers[0].description
+    ret = ret and '(2)' in tg_inv.transformers[1].description
+    ret = ret and '(1)' in tg_inv.transformers[2].description
+
+    tr = Transformer.from_crs(31370, 3812)
+
+    points = np.array([[100000, 200000], [110000, 210000], [120000, 220000]])
+
+    transformed_points_3 = tg.transformers[0].transform(points[:, 0], points[:, 1])
+    transformed_points_2 = tg.transformers[1].transform(points[:, 0], points[:, 1])
+    transformed_points_1 = tg.transformers[2].transform(points[:, 0], points[:, 1])
+    transformed_points = tr.transform(points[:, 0], points[:, 1])
+    transform_wolf = transform_coordinates(points, inputEPSG='EPSG:31370', outputEPSG='EPSG:3812')
+
+    # Convert to numpy arrays
+    transformed_points_3 = np.array(transformed_points_3).T
+    transformed_points_2 = np.array(transformed_points_2).T
+    transformed_points_1 = np.array(transformed_points_1).T
+    transformed_points = np.array(transformed_points).T
+
+    # Assert that the transformed points are equal
+    ret = ret and np.all(transformed_points_3 == transform_wolf)
+    ret = ret and np.all(transformed_points_3 == transformed_points)
+    ret = ret and not np.all(transformed_points_2 == transformed_points)
+    ret = ret and not np.all(transformed_points_1 == transformed_points)
+
+    return ret
 
 def main():
     # Check if installation is complete
@@ -32,13 +125,53 @@ def main():
         ret += 'Error during osgeo import - GDAL/OGR not/bad installed\n Please (re)install GDAL (64 bits version) from https://github.com/cgohlke/geospatial-wheels/releases\n\n'
         ret += 'Error : ' + str(e) + '\n\n'
 
+    if 'pyproj' in packages:
+        ret += 'PyProj seems installed\n\n'
+        try:
+            conv = test_conversion_LBT72_LBT08()
+
+            if conv:
+                ret += 'NTv2 conversion from Lambert 72 to Lambert 2008 seems available\n\n'
+            else:
+                ret += 'NTv2 conversion from Lambert 72 to Lambert 2008 seems NOT available\n\n'
+                ret += 'Please check if the PROJ data files are installed correctly - See OSGOE4W instructions\n\n'
+        except ImportError as e:
+            ret += 'PyProj not installed properly\n Please install PyProj from "pip install pyproj"\n\n'
+            ret += 'Error : ' + str(e) + '\n\n'
+
+        try:
+            conv = test_conversion_LBT08_LBT72()
+
+            if conv:
+                ret += 'NTv2 conversion from Lambert 2008 to Lambert 72 seems available\n\n'
+            else:
+                ret += 'NTv2 conversion from Lambert 2008 to Lambert 72 seems NOT available\n\n'
+                ret += 'Please check if the PROJ data files are installed correctly - See OSGOE4W instructions\n\n'
+        except ImportError as e:
+            ret += 'PyProj not installed properly\n Please install PyProj from "pip install pyproj"\n\n'
+            ret += 'Error : ' + str(e) + '\n\n'
+
+        try:
+            conv = test_transform_coordinates()
+            if conv:
+                ret += 'Transform coordinates function seems working fine\n\n'
+            else:
+                ret += 'Transform coordinates function seems NOT available\n\n'
+                ret += 'Please check if the PROJ data files are installed correctly - See OSGOE4W instructions\n\n'
+        except ImportError as e:
+            ret += 'PyProj not installed properly\n Please install PyProj from "pip install pyproj"\n\n'
+            ret += 'Error : ' + str(e) + '\n\n'
+
+    else:
+        ret += 'PyProj not installed\n Please install PyProj from "pip install pyproj"\n\n'
+
     if 'wolfgpu' in packages:
         ret += 'WolfGPU seems installed\n\n'
     else:
         ret += 'WolfGPU not installed\n Please install WolfGPU if needed\n\n'
 
     # try:
-    #     from ..libs import wolfpy
+    #     from wolf_libs import wolfpy
     #     ret += 'Wolfpy accessible\n\n'
     # except ImportError as e:
     #     ret += 'Wolfpy not accessible\n\n'

wolfhece/apps/splashscreen.py

@@ -23,7 +23,7 @@ import time
 from   wx.adv import SplashScreen as SplashScreen,SPLASH_CENTRE_ON_SCREEN,SPLASH_TIMEOUT,Sound
 
 try:
-    from ..libs import wolfogl
+    from wolf_libs import wolfogl
 except ImportError:
     print("** WolfOGL not found **")
     print("Without WolfOGL, the application will not work !")

wolfhece/apps/version.py

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

wolfhece/cli.py

@@ -15,7 +15,8 @@ def check():
 
 def license():
     """ Main wolf application : License """
-    from .libs.wolfogl import request_license
+    from wolf_libs.wolfogl import request_license
+
     from pathlib import Path
 
     if Path(__file__).parent / 'license' / 'wolf.lic':
@@ -76,6 +77,100 @@ def hydro():
     from .apps.wolfhydro import main
     main()
 
+def report_gpu():
+    """ Application for generating GPU simulation reports """
+    from .report.simplesimgpu import SimpleSimGPU_Report
+
+    # récupère l'argument de la ligne de commande
+    from pathlib import Path
+    import sys
+    n = len(sys.argv)
+
+    if n == 3:
+        outpath = Path(sys.argv[2])
+        mydir = Path(sys.argv[1])
+    elif n == 2:
+        outpath = Path('.')
+        mydir = Path(sys.argv[1])
+    else:
+        print('Usage: wolf_report_gpu <directory> or wolf_report_gpu <directory> <directory_out>')
+
+    if n in [2, 3]:
+        if mydir.exists():
+            report = SimpleSimGPU_Report(mydir)
+            report.create_report()
+            report.save_report(outpath / (mydir.name + '_report.pdf'))
+        else:
+            print('Directory not found')
+    else:
+        print('Usage: wolf_report_gpu <directory>')
+
+def reports_gpu():
+    """ Application for generating GPU simulation reports """
+    from .report.simplesimgpu import SimpleSimGPU_Report
+
+    # récupère l'argument de la ligne de commande
+    from pathlib import Path
+    import glob
+    import sys
+    n = len(sys.argv)
+
+    if n == 3:
+        outpath = Path(sys.argv[2])
+        mydir = Path(sys.argv[1])
+    elif n == 2:
+        mydir = Path(sys.argv[1])
+        outpath = Path('.')
+    else:
+        print('Usage: wolf_reports_gpu <directory> or wolf_reports_gpu <directory> <directory_out>')
+
+    if n in [2, 3]:
+        if mydir.exists():
+            # find all sims in the directory
+            sim_dirs = Path(mydir).rglob('parameters.json')
+            sim_dirs = [Path(d).parent for d in sim_dirs]
+            if not sim_dirs:
+                print('No simulation directories found in {}'.format(mydir))
+                return
+            # create a report for each simulation
+            for sim_dir in sim_dirs:
+                print('Creating report for {}'.format(sim_dir))
+                report = SimpleSimGPU_Report(sim_dir)
+                report.create_report()
+                report.save_report(outpath / (sim_dir.name + '_report.pdf'))
+        else:
+            print('Directory not found')
+
+def report_compare():
+    """ Application for comparing GPU simulation reports """
+    from .report.simplesimgpu import SimpleSimGPU_Report_Compare
+
+    # récupère l'argument de la ligne de commande
+    from pathlib import Path
+    import sys
+    n = len(sys.argv)
+    if n == 2:
+        mydir = Path(sys.argv[1])
+        if mydir.exists():
+            report = SimpleSimGPU_Report_Compare(mydir)
+            report.create_report()
+            report.save_report(mydir.name + '_report_compare.pdf')
+        else:
+            print('Directory not found')
+    elif n > 2:
+        files = [Path(f) for f in sys.argv[1:]]
+        if all(f.exists() for f in files):
+            report = SimpleSimGPU_Report_Compare(files)
+            report.create_report()
+            report.save_report('report_compare.pdf')
+        else:
+            for f in files:
+                if not f.exists():
+                    print('File {} not found'.format(f))
+    else:
+        print('Usage: wolf_report_compare <directory> or wolf_report_compare <file1> <file2> ...')
+
+
 def compare():
     """ Application for comparing 2D arrays """
     from .apps.wolfcompare2Darrays import main

wolfhece/hydrology/Optimisation.py

@@ -19,6 +19,8 @@ from matplotlib.backends.backend_wxagg import (
 import shutil
 import ctypes as ct
 
+
+import wolf_libs
 from .PostProcessHydrology import PostProcessHydrology
 from .Catchment import *
 from .Comparison import *
@@ -148,7 +150,10 @@ class Optimisation(wx.Frame):
         self.myParams = {}
         self.myParamsPy = {}
         self.nbParams = 0
-        self.pathDll = Path(os.path.dirname(__file__)).parent
+
+        #self.pathDll = Path(os.path.dirname(__file__)).parent
+        # point to the wolf_libs package directory
+        self.pathDll = wolf_libs.__path__[0]
 
         self.callBack_proc = {}
         self.callBack_ptr = {}
@@ -234,8 +239,8 @@ class Optimisation(wx.Frame):
         self.Bind(wx.EVT_MENU, self.launch_models_propertie_with_Nash, testEquiFinClick)
         plotEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Plot analysis with Nash')
         self.Bind(wx.EVT_MENU, self.plot_model_analysis, plotEquiFinClick)
-        
-        
+
+
 
         # Creation of the Lauch Menu
         launchMenu = wx.Menu()
@@ -2021,7 +2026,7 @@ class Optimisation(wx.Frame):
                             myGroup = myModelDict[int(myType)]["Group"][iFile]
                             myKey = myModelDict[int(myType)]["Key"][iFile]
                             self.write_one_opti_param(filePath, fileName, myGroup, myKey, params[i], convers_factor=convFact[iFile])
-                else:               
+                else:
                     self.curParams_vec_F[i] = params[i]
                     self.update_timeDelay(i+1)
                     refCatch.save_timeDelays([self.myParams[i+1]["junction_name"]])
@@ -2676,10 +2681,10 @@ class Optimisation(wx.Frame):
         logging.info("The equifinality test is finished!")
 
 
-    def get_best_params(self, stationOut:str, 
+    def get_best_params(self, stationOut:str,
                         criterion:str="Nash", quantile:float=0.99, std:float=0.05, eps:float=0.2, rmv_near_max=1e-4, nb_rand_close:int=10,
                         objective_fct:bool= True, apply_clustering:bool=False, objective_weight:float=1.0):
-        from sklearn.cluster import DBSCAN        
+        from sklearn.cluster import DBSCAN
         """
         Get the best parameters for a given station.
 
@@ -2832,10 +2837,10 @@ class Optimisation(wx.Frame):
             return None
         cur_fracts = curBasin.get_volume_fractions(interval=intervals)
         return cur_fracts
-    
-    def _get_flow_fractions(self, idLauncher:int=0, stationOut:str="", 
+
+    def _get_flow_fractions(self, idLauncher:int=0, stationOut:str="",
                          intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> dict[list[str], list[float]]:
-        
+
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
         cur_key = curCatch.get_key_catchmentDict(stationOut)
         curBasin: SubBasin = curCatch.catchmentDict[cur_key]
@@ -2844,11 +2849,11 @@ class Optimisation(wx.Frame):
             return None
         cur_fracts = curBasin.get_flow_fractions(interval=intervals, summary="mean")
         return cur_fracts
-    
 
-    def _get_punctual_reservoir_fractions(self, eval_date:datetime.datetime, 
+
+    def _get_punctual_reservoir_fractions(self, eval_date:datetime.datetime,
                                           idLauncher:int=0, stationOut:str="") -> dict[list[str], list[float]]:
-        
+
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
         cur_key = curCatch.get_key_catchmentDict(stationOut)
         curBasin: SubBasin = curCatch.catchmentDict[cur_key]
@@ -2856,7 +2861,7 @@ class Optimisation(wx.Frame):
             logging.warning("The current module is not a SubBasin object!")
             return None
         linked_params = mc.MODELS_VAR[curBasin.model].get_all_linked_params()
-        i_params = self._get_key_from_type_all_parameters(list(linked_params.values()))    
+        i_params = self._get_key_from_type_all_parameters(list(linked_params.values()))
         max_params = {var_name: self.myParams[i_params[param_id]]["value"] for var_name, param_id in linked_params.items()}
         cur_fracts = curBasin.get_iv_fractions_one_date(max_params=max_params, eval_date=eval_date)
         return cur_fracts
@@ -3021,7 +3026,7 @@ class Optimisation(wx.Frame):
                     cur_columns = [col for col in df.columns if cur_prop in col.replace(" ", "")]
                     if cur_columns != []:
                         corr_prop = cur_columns[0]
-                        ax.scatter(df.loc[:,corr_prop], df.loc[:,y_label], s=0.5, c=cur_color, 
+                        ax.scatter(df.loc[:,corr_prop], df.loc[:,y_label], s=0.5, c=cur_color,
                                    marker='o', label=cur_prop, alpha=0.4)
                 ax.set_xlabel("% of the rain [-]")
                 ax.set_ylabel(y_label+" [-]")
@@ -3049,10 +3054,10 @@ class Optimisation(wx.Frame):
                 ax.set_title("Peak analysis : "+stationOut)
                 ax.legend()
                 fig.savefig(os.path.join(self.workingDir, "Equifinality_peaks_ratio_"+stationOut+".png"))
-                
+
             else:
                 logging.error("The file "+filename+" does not exist!")
-                
+
         plt.show()
 
 
@@ -3212,7 +3217,7 @@ class Optimisation(wx.Frame):
 
     # FIXME : this function has been dashed off -> functionnal but not well written!!
     # TODO : to improve !!!!!!
-    def launch_models_propertie_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=True, 
+    def launch_models_propertie_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=True,
                                           save_every:int=100, restart_from_file:bool=True):
         """
         Analyse the properties of the model and compare them with the Nash coefficient.
@@ -3232,11 +3237,11 @@ class Optimisation(wx.Frame):
         if onlyOwnSub is None:
             onlyOwnSub = False
         doneList = []
-        previousLevel = 1 
+        previousLevel = 1
         # Collect sort and save the compare stations
         self.set_compare_stations(idLauncher=idLauncher)
         sortJct = self.myStations
-        # Get the initial number of intervals 
+        # Get the initial number of intervals
         # -> these can evolve according to the measurement available at each station
         is_ok = self._save_opti_intervals()
         all_intervals = self.all_intervals
@@ -3268,14 +3273,14 @@ class Optimisation(wx.Frame):
             # Reload the useful modules
             self.reload_hydro(idCompar=0, fromStation=stationOut, lastLevel=previousLevel, updateAll=True)
             ## =======
-            ## Init 
+            ## Init
             ## =======
             self.init_optimizer(idOpti)
             self.associate_ptr(None, idOpti=idOpti)
             # Get the best parameters to test
             all_params = self.get_best_params(stationOut=stationOut, quantile=quantile_Nash, std=std_Nash, rmv_near_max=1e-4, apply_clustering=clustering_Nash)
             ## =======
-            ## Compute 
+            ## Compute
             ## =======
             all_frac = []
             # Check if the excel file already exists and load it to check if some parameters have already been tested
@@ -3307,7 +3312,7 @@ class Optimisation(wx.Frame):
                 cur_all_frac = (list(cur_p)
                                 + cur_timeDelays
                                 + list(frac_flow_dict.values())
-                                + list(init_iv.values()) 
+                                + list(init_iv.values())
                                 + [p_excess, max_sim_obs, cur_obj])
                 all_frac.append(cur_all_frac)
                 # Periodically save the evaluations in case of trouble
@@ -3364,14 +3369,14 @@ class Optimisation(wx.Frame):
     # FIXME : it might be better to pass the myParams to the CaseOpti object instead to allow parallelisation
     def _build_type_to_key_index(self) -> dict[int, int]:
         return {param["type"]: i for i, param in self.myParams.items()}
-    
+
     def _get_key_from_type_all_parameters(self, list_type_param: list[int]) -> dict[int | None]:
         type_to_key = self._build_type_to_key_index()
         return {cur_key: type_to_key.get(cur_key) for cur_key in list_type_param}
 
     def _get_key_from_type_parameter(self, type_param:int) -> int:
         return next((i for i, param in self.myParams.items() if param["type"] == type_param), None)
-    
+
 
     def make_nd_array(self, c_pointer, shape, dtype=np.float64, order='C', own_data=True,readonly=False):
         arr_size = np.prod(shape[:]) * np.dtype(dtype).itemsize
@@ -3417,5 +3422,5 @@ class Optimisation(wx.Frame):
             # Remove the parameters that have already been tested
             new_params = np.array([el for el in all_params if ~np.any(np.all(np.isclose(all_params_tested, el[:-1], atol=1e-6), axis=1))])
             return all_data_tested, new_params
-        
+
         return [], all_params

wolfhece/irm_qdf.py

@@ -746,4 +746,70 @@ class QDF_Belgium():
                     return None
             else:
                 logging.error(f"Name {key} not found in the data")
-                return None
+                return None
+
+
+class Climate_IRM():
+
+    def __init__(self, store_path= 'irm', ins:Literal['2018', '2019', '2025', 2018, 2019, 2025] = 2018) -> None:
+        self.store_path = Path(store_path)
+        self.localities = Localities(ins)
+
+        self._climate_data = {}
+
+    def __getitem__(self, key):
+        return self._climate_data[key]
+
+    @classmethod
+    def importfromwebsite(cls, store_path= 'irm', verbose:bool= False, waitingtime:float= .01, ins:Literal['2018', '2019', '2025', 2018, 2019, 2025] = 2018, ins_code: int = None):
+        """ Import Excel files for one or all municipalities from the IRM website
+
+        :param store_path: Where to store the downloaded data. Directory will be created if it doesn't exists.
+        :param verbose: If `True`, will print some progress information.
+                        If `False`, will do nothing.
+                        If a callable, then will call it with a float in [0, 1].
+                        0 means nothing downloaded, 1 means everything downloaded.
+
+        :param waitingtime: How long to wait (in seconds) betwenn the download
+                            of each station (will make sure we don't overwhelm IRM's website).
+
+        :param ins: The year of the INS codes to use.
+        :param code: Restricts the data download to a specific NIS code. `None` means full download.
+        """
+        import requests
+
+        myloc = Localities(ins)
+
+        if ins_code is not None:
+            codes_to_load = [ins_code]
+        else:
+            if not path.exists(store_path):
+                mkdir(store_path)
+            codes_to_load = myloc.inscode2name
+
+        for key,myins in enumerate(codes_to_load):
+            #chaîne URL du fichier Excel
+            url="https://www.meteo.be//resources//climatology//climateCity//pdf//climate_INS"+str(myins)+"_9120_fr.pdf"
+            #Obtention du fichiers depuis le site web de l'IRM
+            response=requests.get(url)
+
+            if str(response.content).find("Page not found")==-1 :
+
+                # Make sure we create the store path only if we have
+                # something to put inside.
+                if ins_code is not None and not path.exists(store_path):
+                    mkdir(store_path)
+
+                file=open(path.join(store_path,str(myins)+".pdf"), 'wb')
+                file.write(response.content)
+                file.close()
+                if verbose:
+                    if callable(verbose):
+                        verbose(key/len(codes_to_load))
+                    else:
+                        print(myins)
+            else:
+                #logging.error(response.content)
+                logging.error(f"Failed to load IRM data: {url} --> {response}")
+
+            sleep(waitingtime)

wolfhece/mesh2d/wolf2dprev.py

@@ -11484,7 +11484,8 @@ class prev_sim2D():
         if len(lst) == 0:
             logging.warning('No potential BC found -- Test can not be performed -- I continue anyway')
         else:
-            if i not in lst[0] or j not in lst[1]:
+            candidate_cells = list(zip(lst[0], lst[1]))
+            if (i, j) not in candidate_cells:
                 logging.error(f'Invalid indices ({i},{j}) - BC not added')
                 return
 
@@ -11506,7 +11507,8 @@ class prev_sim2D():
         if len(lst) == 0:
             logging.warning('No potential BC found -- Test can not be performed -- I continue anyway')
         else:
-            if i not in lst[0] or j not in lst[1]:
+            candidate_cells = list(zip(lst[0], lst[1]))
+            if (i, j) not in candidate_cells:
                 logging.error(f'Invalid indices ({i},{j}) - BC not added')
                 return
 

wolfhece/report/pdf.py

@@ -0,0 +1,55 @@
+""" WX Frame displaying a PDF file """
+import wx
+import wx.lib.sized_controls as sc
+from wx.lib.pdfviewer import pdfViewer, pdfButtonPanel
+
+from pathlib import Path
+
+class PDFViewer(sc.SizedFrame):
+
+    def __init__(self, parent, **kwargs):
+        """ Initialize the PDF Viewer Frame """
+        super(PDFViewer, self).__init__(parent, **kwargs)
+
+        paneCont = self.GetContentsPane()
+        self.buttonpanel = pdfButtonPanel(paneCont, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0)
+        self.buttonpanel.SetSizerProps(expand=True)
+
+        self.viewer:pdfViewer
+        self.viewer = pdfViewer(paneCont, wx.ID_ANY, wx.DefaultPosition,
+                                wx.DefaultSize,
+                                wx.HSCROLL|wx.VSCROLL|wx.SUNKEN_BORDER)
+
+        self.viewer.SetSizerProps(expand=True, proportion=1)
+
+        # introduce buttonpanel and viewer to each other
+        self.buttonpanel.viewer = self.viewer
+        self.viewer.buttonpanel = self.buttonpanel
+
+        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)
+
+
+    def load_pdf(self, pdf_path:str):
+        """ Load a PDF file into the viewer """
+
+        if not Path(pdf_path).exists():
+            wx.MessageBox("PDF file does not exist.", "Error", wx.OK | wx.ICON_ERROR)
+            return
+
+        try:
+            self.viewer.LoadFile(str(pdf_path))
+        except Exception as e:
+            wx.MessageBox("Failed to load PDF file.", "Error", wx.OK | wx.ICON_ERROR)
+
+if __name__ == '__main__':
+    import wx.lib.mixins.inspection as WIT
+    app = WIT.InspectableApp(redirect=False)
+
+    pdfV = PDFViewer(None)
+    pdfV.load_pdf(Path(__file__).parent.parent.parent /'tests' / 'data' / 'pdf' / "dummy.pdf")  # Change to your PDF file path
+    pdfV.Show()
+
+    app.MainLoop()