wolfhece 2.1.7__py3-none-any.whl → 2.1.9__py3-none-any.whl

wolfhece/PyParams.py

@@ -944,7 +944,11 @@ class Wolf_Param(wx.Frame):
                     except:
                         logging.debug("String type will be conserved! -- {}".format(value_param))
 
-                page.AppendIn(parent, pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=value_param))
+                if type(value_param) != int:
+                    logging.warning("Parameters -- EnumProperty -- Value {} is not an integer".format(value_param))
+                    logging.debug("EnumProperty value must be an integer")
+
+                page.AppendIn(parent, pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=int(value_param))) # force value to 'int' type
             else:
                 self._insert_with_type_based_on_value(page, group, param, prefix)
 
@@ -1055,8 +1059,12 @@ class Wolf_Param(wx.Frame):
                         value_param = int(value_param)
                     except:
                         logging.debug("String type will be conserved! -- {}".format(value_param))
-                # print(value_param)
-                page.Append(pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=value_param))
+
+                if type(value_param) != int:
+                    logging.warning("Parameters -- EnumProperty -- Value {} is not an integer".format(value_param))
+                    logging.debug("EnumProperty value must be an integer")
+
+                page.Append(pg.EnumProperty(label= param_name, name= locname, labels= list_keys, values= list_values, value= int(value_param)))
 
             else:
                 # Pas de chaîne JSON mais un commentaire complet

wolfhece/apps/version.py

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

wolfhece/multiprojects.py

@@ -80,7 +80,103 @@ class Wolf2D_Project(Project):
         self.poly = None
         self.poly_values = None
 
-    def load_simulations(self, epsilon, verbose=False):
+    @classmethod
+    def from_existing(cls, sims:dict[str, Union[str, Wolfresults_2D, wolfres2DGPU]]):
+        """
+        Create a MultiProjects object from a dictionary of simulations
+
+        :param sims: dict[str, Union[str, Wolfresults_2D, wolfres2DGPU]] -- dictionary of simulations to add
+        """
+
+        newmp = cls(to_read=False)
+        newmp.add_simulations(sims)
+
+        return newmp
+
+    def __str__(self) -> str:
+        """
+        Return string representation
+        """
+
+        ret = f'Project : {Path(self.wdir)}\n'
+        ret += 'Key : Simulations : Type\n'
+        for curkey, cursim in self.mysims.items():
+            ret+=f'{curkey} : {cursim.filename} : {"GPU" if isinstance(cursim, wolfres2DGPU) else "CPU"}\n'
+
+        return ret
+    
+    def __getitem__(self, key: tuple[str, str]):
+        
+        return self.get_simulation(key)
+
+    def pop(self, key: str):
+        """
+        Remove a simulation from the project
+
+        :param key: str -- key of the simulation to remove
+        """
+
+        if key in self.mysims.keys():
+            self.mysims.pop(key)
+    
+    def add(self, 
+            key:str, 
+            value:Union[Wolfresults_2D, wolfres2DGPU, str], 
+            epsilon:float=None, 
+            force_read:bool = False):
+        """
+        Add a key-value pair to the project
+
+        :param key: str -- key of the simulation to add
+        :param value: Wolfresults_2D, wolfres2DGPU, str -- simulation to add
+        :param epsilon: float -- epsilon value to use for the simulation
+        :param force_read: bool -- force reading the last step of the simulation
+
+        """
+
+        if epsilon is  None:
+            epsilon = self.epsilon
+
+        if isinstance(value, str):
+            
+            locpath = Path(self.wdir) / value
+            if locpath.exists():
+
+                if 'simul_gpu_results' in locpath.name or (locpath / 'simul_gpu_results').exists():
+                    #GPU
+                    self.mysims[key] = wolfres2DGPU(locpath, epsilon=self.epsilon, idx=key)
+                else:
+                    #CPU
+                    self.mysims[key] = Wolfresults_2D(locpath, epsilon=self.epsilon, idx=key)
+
+            else:
+                logging.warning(f'File {locpath} does not exist !')
+
+        elif isinstance(value, wolfres2DGPU):
+
+            self.mysims[key] = value
+
+        elif isinstance(value, Wolfresults_2D):
+                
+            self.mysims[key] = value
+
+        if force_read:
+            self.mysims[key].read_oneresult()
+            
+    def add_simulations(self, 
+                        sims_to_add:dict[str, Union[str, Wolfresults_2D, wolfres2DGPU]],
+                        epsilon:float=None, 
+                        force_read:bool = False):
+        """
+        Add multiple simulations to the project
+
+        :param sims_to_add: dict[str, Union[str, Wolfresults_2D, wolfres2DGPU]] -- dictionary of simulations to add
+        """
+
+        for key, value in sims_to_add.items():
+            self.add(key, value, epsilon, force_read)
+
+    def load_simulations(self, epsilon:float, verbose:bool=False):
         """
         Load all simulations in current project
         """
@@ -92,6 +188,7 @@ class Wolf2D_Project(Project):
             for key,val in sims_wolf2d.items():
                 if verbose:
                     print(key)
+                    logging.info(f'Loading simulation {key} : {val[key_Param.VALUE]}')
 
                 cursim = self.mysims[key] = Wolfresults_2D(join(self.wdir, val[key_Param.VALUE]), eps=epsilon, idx=key)
                 cursim.plotted=True
@@ -102,6 +199,7 @@ class Wolf2D_Project(Project):
             for key,val in sims_gpu2d.items():
                 if verbose:
                     print(key)
+                    logging.info(f'Loading simulation {key} : {val[key_Param.VALUE]}')
 
                 cursim = self.mysims[key] = wolfres2DGPU(Path(join(self.wdir, val[key_Param.VALUE])), eps=epsilon, idx=key)
                 cursim.plotted=True
@@ -128,6 +226,23 @@ class Wolf2D_Project(Project):
         for cursim in self.mysims.values():
             cursim.read_oneresult()
 
+    def get_simulation(self, key:Union[str,int]) -> Union[Wolfresults_2D, wolfres2DGPU]:
+        """
+        Get simulation by key
+
+        :param key: str or int -- key of the simulation to get or index of the simulation to get
+        """
+
+        if isinstance(key,int):
+            if key >=0 and key <len(self.mysims):
+                return self.mysims[self.mysims.keys()[key]]
+
+        elif isinstance(key,str):
+            if key in self.mysims.keys():
+                return self.mysims[key]
+
+        return None
+    
     def get_simulations(self) -> list:
         """
         Return a python list of simulations
@@ -274,15 +389,58 @@ class Wolf2D_Project(Project):
 
 class MultiProjects():
     """Manager of multiple project files"""
+
     def __init__(self, wdir='') -> None:
 
         self.projects:dict[str, Wolf2D_Project]={}
         self.wdir=wdir
 
+    def __getitem__(self, key:Union[str,int]) -> Project:
+        """
+        Get project by key
+        """
+
+        return self.get_project(key)
+    
+    def get_one_simulation(self, key_project:str, key_sim:str) -> Union[Wolfresults_2D, wolfres2DGPU]:
+        """
+        Get one simulation by key in a project
+        """
+
+        if key_project in self.projects.keys():
+            return self.projects[key_project].get_simulation(key_sim)
+
+        return None
+
+    def get_same_simulation_in_projects(self, key_sim:str) -> dict[str, Union[Wolfresults_2D, wolfres2DGPU]]:
+        """
+        Get simulation by key in all projects
+        """
+
+        allsims = {}
+        for curkey, curproj in self.projects.items():
+            cursim = curproj.get_simulation(key_sim)
+            if cursim is not None:
+                allsims[curkey + ' - ' + key_sim] = cursim
+
+        return allsims
+
+    def __str__(self) -> str:
+        """
+        Return string representation
+        """
+
+        ret = 'Key : Directory\n'
+        for curkey,curproj in self.projects.items():
+            ret+=f'{curkey} : {Path(curproj.wdir)}\n'
+
+        return ret
+
     def add(self, project:Project, key=str, whichtype=project_type.GENERIC):
         """
         Add project to dict
         """
+
         if isinstance(project,str):
             if exists(project):
                 pass
@@ -300,6 +458,7 @@ class MultiProjects():
         """
         Récupération d'un projet sur base du nom ou d'une position
         """
+
         if isinstance(key,int):
             if key >=0 and key <len(self.projects):
                 return self.projects[self.projects.keys()[key]]
@@ -309,11 +468,12 @@ class MultiProjects():
                 return self.projects[key]
 
         return None
-
+    
     def read(self, filepath:str):
         """
         Read from file
         """
+
         if exists(filepath):
             with open(filepath,'r') as f:
                 self.projects = json.load(f)
@@ -322,6 +482,7 @@ class MultiProjects():
         """
         Write to file
         """
+
         with open(filepath,'w') as f:
             json.dump(self.projects,f)
 
@@ -329,6 +490,7 @@ class MultiProjects():
         """
         Load all simulations in projects
         """
+
         for keyp,valp in self.projects.items():
             print(keyp)
             valp.load_simulations(epsilon, verbose)
@@ -337,11 +499,12 @@ class MultiProjects():
         """
         Update all simulations in projects
         """
+
         for keyp,valp in self.projects.items():
             print(keyp)
             valp.update_simulations(epsilon, verbose)
 
-    def get_simulations_list(self, which_project=None) -> list:
+    def get_simulations_list(self, which_project:Union[str, list[str]]=None) -> list:
         """
         Return a python list of simulations
 

wolfhece/pybridges.py

@@ -31,6 +31,7 @@ class stored_values_unk(Enum):
     UNORM      = (5, views_2D.UNORM.value)
     FROUDE     = (6, views_2D.FROUDE.value)
     WATERLEVEL = (7, views_2D.WATERLEVEL.value)
+    WATERSTAGE = (7, views_2D.WATERLEVEL.value)
     TOPOGRAPHY = (8, views_2D.TOPOGRAPHY.value)
     HEAD       = (-1, _('Difference of waterlevel (up-down)'))
     DIFFERENCE_Z_UP_DOWN    = (-1, _('Difference of waterlevel (up-down)'))

wolfhece/pypolygons_scen.py

@@ -7,20 +7,151 @@ from typing import Literal, Union
 import matplotlib.pyplot as plt
 from enum import Enum
 import logging
+from pathlib import Path
 
 from .PyTranslate import _
 from .PyVertexvectors import Zones, zone, vector, vectorproperties, getIfromRGB
 from .drawing_obj import Element_To_Draw
 from .PyTranslate import _
-from .wolfresults_2D import views_2D
+from .wolfresults_2D import views_2D, Wolfresults_2D
+from .Results2DGPU import wolfres2DGPU
 from .pybridges import stored_values_pos,stored_values_unk, parts_values, operators, stored_values_coords
 
+from zipfile import ZIP_DEFLATED, ZipFile
+
+class ZipFileWrapper(ZipFile):
+    def open(self, name="data", mode="r", pwd=None, **kwargs):
+        return super().open(name=name, mode=mode, pwd=pwd, **kwargs)
+
+    def read(self):
+        return super().read(name="data")
+
 class Extracting_Zones(Zones):
+    """ 
+    Classe permettant de récupérer les valeurs à l'intérieur des polygones
+    définis dans plusieurs zones.
+
+    Ces polygones ne sont pas nécessairement ordonnés ou relatifs au lit mineur.
+    
+    """
 
     def __init__(self, filename='', ox: float = 0, oy: float = 0, tx: float = 0, ty: float = 0, parent=None, is2D=True, idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
         super().__init__(filename, ox, oy, tx, ty, parent, is2D, idx, plotted, mapviewer, need_for_wx)
-        self.parts = {}
-        self.linked = {}
+        
+        self.parts:dict = None
+        self.linked:Union[dict, list] = None
+
+    def cache_data(self, outputfile:str):
+        """
+        Serialize the values in a file
+        """
+        self._serialize_values(outputfile)
+
+    def load_data(self, inputfile:str):
+        """
+        Deserialize the values from a file
+        """
+        self._deserialize_values(inputfile)
+
+    def _serialize_values(self, outputfile:str):
+        """
+        Serialize the values in a file
+        """
+        
+        import json
+        from codecs import getwriter
+        from typing import IO
+
+        class NumpyArrayEncoder(json.JSONEncoder):
+            def default(self, obj):
+                if isinstance(obj, np.integer):
+                    return int(obj)
+                elif isinstance(obj, np.floating):
+                    return float(obj)
+                elif isinstance(obj, np.ndarray):
+                    return obj.tolist()       
+                elif obj == Wolfresults_2D:
+                    return 'CPU'
+                elif obj == wolfres2DGPU:
+                    return 'GPU'         
+                
+                return json.JSONEncoder.default(self, obj)        
+
+        def _json_dump_bytes(fp: IO, obj):
+            StreamWriter = getwriter("utf-8")
+            return json.dump(fp=StreamWriter(fp), obj=obj, cls=NumpyArrayEncoder, indent=4)
+
+        def json_dump_zip(fp: IO, obj):
+            with ZipFileWrapper(fp, mode="w", compression=ZIP_DEFLATED, compresslevel=9) as zip_file:
+                with zip_file.open(mode="w") as _fp:
+                    _json_dump_bytes(fp=_fp, obj=obj)
+
+
+        with open(outputfile, 'wb') as f:
+
+            json_dump_zip(fp = f, obj = {'linked' : self.linked, 'values': self.parts})
+
+
+    def _deserialize_values(self, inputfile:str):
+        """
+        Deserialize the values from a file
+        """
+        
+        import json
+        from codecs import getwriter
+        from typing import IO
+
+        def json_load_zip(fp: IO):
+            with ZipFileWrapper(fp, mode="r") as zip_file:
+                return json.load(zip_file)
+
+        inputfile = Path(inputfile)
+        if not inputfile.exists():
+            logging.error(_('File {0} does not exist').format(inputfile))
+            return
+
+        with open(inputfile, 'rb') as f:
+            data = json_load_zip(f) #json.load(f)
+
+        tmp_linked = data['linked']
+        if isinstance(tmp_linked, dict):
+            self.linked = {}
+            for curkey, curgroup in tmp_linked.items():
+                self.linked[curkey] = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in curgroup]
+
+            tmp_values = data['values']
+            self.parts = {}
+
+            for cuzone, curparts in tmp_values.items():
+                self.parts[cuzone] = {}
+
+                for curproj, curdict in curparts.items():
+                    self.parts[cuzone][curproj] = {}
+                    for curpoly, curval in curdict.items():
+                        self.parts[cuzone][curproj][curpoly] = {}
+                        for curgroup, curarray in curval.items():
+                            locdict = self.parts[cuzone][curproj][curpoly][curgroup] = {}
+                            
+                            for cursim, curnparray in curarray.items():
+                                locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+                        
+        elif isinstance(tmp_linked, list):
+            self.linked = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in tmp_linked]
+
+            tmp_values = data['values']
+            self.parts = {}
+
+            for cuzone, curparts in tmp_values.items():
+                self.parts[cuzone] = {}
+
+                for curpoly, curval in curparts.items():
+                    self.parts[cuzone][curpoly] = {}
+                    for curgroup, curarray in curval.items():
+                            locdict = self.parts[cuzone][curpoly][curgroup] = {}
+                            
+                            for cursim, curnparray in curarray.items():
+                                locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+
 
     def find_values_inside_parts(self, linked_arrays):
         """
@@ -45,13 +176,14 @@ class Extracting_Zones(Zones):
 
             self.linked = [(curlink.idx, type(curlink)) for curlink in linked_arrays]
 
+        self.parts = {}
         for curzone in self.myzones:
-
             if isinstance(linked_arrays, dict):
                 locparts = self.parts[curzone.myname] = {}
                 for curkey, curgroup in linked_arrays.items():
                     locparts[curkey] = curzone.get_all_values_linked_polygon(curgroup, key_idx_names='name', getxy=True)
-            elif isinstance(linked_arrays, list):
+            
+            elif isinstance(linked_arrays, list):    
                 self.parts[curzone.myname]  = curzone.get_all_values_linked_polygon(linked_arrays, key_idx_names='name', getxy=True)
 
     def _get_heads(self,
@@ -228,6 +360,14 @@ class Extracting_Zones(Zones):
 
 class Polygons_Analyze(Zones):
     """
+    Classe permettant de récupérer les valeurs à l'intérieur des polygones
+    définis dans la dernière zone d'une fichier .vecz.
+
+    Ce fichier est typiquement le résultat de la création de polygones 
+    sur base de parallèles via l'interface graphique.
+
+    Utile notamment dans l'analyse de modélisations 2D (CPU et/ou GPU).
+
     """
 
     def __init__(self, myfile='', ds:float=5., ox: float = 0, oy: float = 0, tx: float = 0, ty: float = 0, parent=None, is2D=True, wx_exists:bool = False):
@@ -235,13 +375,15 @@ class Polygons_Analyze(Zones):
 
         self.myname = splitext(basename(myfile))[0]
 
-        self.linked = {}
+        self.linked:Union[dict,list] = None # type is depending on the type of linked arrays
+        self.river_values:dict = None
 
         self.riverbed = self.get_zone(0).myvectors[1]
         self.riverbed.prepare_shapely()
 
         self.polygons_zone:zone
         self.polygons_zone = self.get_zone(-1)
+        
         self.polygons_curvi = {}
         for curvert in self.polygons_zone.myvectors:
             self.polygons_curvi[curvert.myname] = curvert.myvertices[0].z
@@ -249,41 +391,130 @@ class Polygons_Analyze(Zones):
         for vec in self.polygons_zone.myvectors:
             vec.myprop.used=False # cache les polygones pour ne pas surcharger l'affichage éventuel
 
-    # def colorize(self):
-    #     """Colorisation des polygones pour l'interface graphique"""
-    #     self.centralpart.myprop.color = getIfromRGB((0,255,0))
-    #     self.upstream.myprop.color = getIfromRGB((255,0,0))
-    #     self.downstream.myprop.color = getIfromRGB((0,0,255))
+    def cache_data(self, outputfile:str):
+        """
+        Serialize the values in a json file -- zipped
+        """
+
+        self._serialize_values(outputfile)
+
+    def load_data(self, inputfile:str):
+        """
+        Deserialize the values from a json file -- zipped
+        """
+
+        self._deserialize_values(inputfile)
 
-    # def highlighting(self, rgb=(255,0,0), linewidth=3):
-    #     """
-    #     Mise en évidence
-    #     """
-    #     self.centralpart.highlighting(rgb,linewidth)
+    def _serialize_values(self, outputfile:str):
+        """
+        Serialize the values in a file
+        """
+        
+        import json
+        from codecs import getwriter
+        from typing import IO
+
+        class NumpyArrayEncoder(json.JSONEncoder):
+            def default(self, obj):
+                if isinstance(obj, np.integer):
+                    return int(obj)
+                elif isinstance(obj, np.floating):
+                    return float(obj)
+                elif isinstance(obj, np.ndarray):
+                    return obj.tolist()       
+                elif obj == Wolfresults_2D:
+                    return 'CPU'
+                elif obj == wolfres2DGPU:
+                    return 'GPU'         
+                
+                return json.JSONEncoder.default(self, obj)        
+
+        def _json_dump_bytes(fp: IO, obj):
+            StreamWriter = getwriter("utf-8")
+            return json.dump(fp=StreamWriter(fp), obj=obj, cls=NumpyArrayEncoder, indent=4)
+
+        def json_dump_zip(fp: IO, obj):
+            with ZipFileWrapper(fp, mode="w", compression=ZIP_DEFLATED, compresslevel=9) as zip_file:
+                with zip_file.open(mode="w") as _fp:
+                    _json_dump_bytes(fp=_fp, obj=obj)
+
+
+        with open(outputfile, 'wb') as f:
+
+            json_dump_zip(fp = f, obj = {'linked' : self.linked, 'values': self.river_values})
+
+
+    def _deserialize_values(self, inputfile:str):
+        """
+        Deserialize the values from a file
+        """
+        
+        import json
+        from codecs import getwriter
+        from typing import IO
+
+        def json_load_zip(fp: IO):
+            with ZipFileWrapper(fp, mode="r") as zip_file:
+                return json.load(zip_file)
+
+        inputfile = Path(inputfile)
+        if not inputfile.exists():
+            logging.error(_('File {0} does not exist').format(inputfile))
+            return
+
+        with open(inputfile, 'rb') as f:
+            data = json_load_zip(f) #json.load(f)
+
+        tmp_linked = data['linked']
+        if isinstance(tmp_linked, dict):
+            self.linked = {}
+            for curkey, curgroup in tmp_linked.items():
+                self.linked[curkey] = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in curgroup]
+
+            tmp_values = data['values']
+            self.river_values = {}
+            for curproj, curdict in tmp_values.items():
+                self.river_values[curproj] = {}
+                for curpoly, curval in curdict.items():
+                    self.river_values[curproj][curpoly] = {}
+                    for curgroup, curarray in curval.items():
+                        locdict = self.river_values[curproj][curpoly][curgroup] = {}
+                        
+                        for cursim, curnparray in curarray.items():
+                            locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+                        
+        elif isinstance(tmp_linked, list):
+            self.linked = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in tmp_linked]
+
+            tmp_values = data['values']
+            self.river_values = {}
+            for curpoly, curval in tmp_values.items():
+                self.river_values[curpoly] = {}
+                for curgroup, curarray in curval.items():
+                        locdict = self.river_values[curpoly][curgroup] = {}
+                        
+                        for cursim, curnparray in curarray.items():
+                            locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
 
-    # def withdrawal(self):
-    #     """
-    #     Mise en retrait
-    #     """
-    #     self.centralpart.withdrawal()
 
     def compute_distance(self, poly:LineString):
         """
         Compute the curvilinear distance along a support polyline
         """
+
         for curvert in self.polygons_zone.myvectors:
+            # Centre du polygone
             centerx = np.sum(np.asarray([cur.x for cur in curvert.myvertices[:4]]))/4.
             centery = np.sum(np.asarray([cur.y for cur in curvert.myvertices[:4]]))/4.
+            
             self.polygons_curvi[curvert.myname] = poly.project(Point([centerx,centery]))
 
-    def find_values_inside_parts(self, linked_arrays, force_reset = False):
+    def find_values_inside_parts(self, linked_arrays:Union[dict,list]):
         """
-        Récupère les valeurs à l'intérieur :
-         - des parties du pont (amont, centrale, aval)
-         - de la discrétisation rivière en polygones
+        Récupère les valeurs à l'intérieur des polygones - dernière zone du fichier
 
-        Retour :
-         - dictionnaire dont la clé est le nom (ou l'index) du polygone dans la zone --> parties centrale, amont ou aval
+        Stockage :
+         - dictionnaire dont la clé est le nom (ou l'index) du polygone dans la zone
          - chaque entrée est un dictionnaire dont la clé 'values' contient un dictionnaire pour chaque matrice du projet
          - chaque élément de ce sous-dictionnaire est un tuple contenant toutes les valeurs utiles
 
@@ -292,11 +523,17 @@ class Polygons_Analyze(Zones):
         ***
 
         """
-        if force_reset:
+
+        if isinstance(linked_arrays, dict):
+
             self.linked={}
 
-        for curkey, curgroup in linked_arrays.items():
-            self.linked[curkey] = [(curlink.idx, type(curlink)) for curlink in curgroup]
+            for curkey, curgroup in linked_arrays.items():
+                self.linked[curkey] = [(curlink.idx, type(curlink)) for curlink in curgroup]
+
+        elif isinstance(linked_arrays, list):
+
+            self.linked = [(curlink.idx, type(curlink)) for curlink in linked_arrays]
 
         # récupération des valeurs danbs les polygones "rivière"
         curzone = self.polygons_zone
@@ -305,12 +542,15 @@ class Polygons_Analyze(Zones):
                 self.river_values={}
                 for curkey, curgroup in linked_arrays.items():
                     self.river_values[curkey] = curzone.get_all_values_linked_polygon(curgroup, key_idx_names='name')
+
             elif isinstance(linked_arrays, list):
+
                 self.river_values = curzone.get_all_values_linked_polygon(linked_arrays, key_idx_names='name')
 
     def _get_river_heads(self,
                        which_group=None):
         """Compute Head"""
+
         head = {}
 
         z   = self.get_river_values(stored_values_unk.WATERLEVEL, which_group)
@@ -403,6 +643,11 @@ class Polygons_Analyze(Zones):
                             which_value:Union[stored_values_unk,stored_values_pos],
                             which_group=None,
                             operator:operators=operators.MEDIAN) -> dict:
+        """ 
+        Get values for the river polygons with an operator 
+        
+        operator : MEDIAN, MIN, MAX, PERCENTILE95, PERCENTILE5, ALL
+        """
 
         def extract_info(vals):
             vals_ret={}
@@ -440,6 +685,32 @@ class Polygons_Analyze(Zones):
 
         return vals_ret
 
+    def get_s_values(self,
+                     which_value:Union[stored_values_unk,stored_values_pos]=stored_values_unk.WATERLEVEL,
+                     which_group:str=None,
+                     which_sim:str=None,
+                     operator:operators=operators.MEDIAN):
+        """ Get the values of the river polygons for a specific simulation """
+
+        s=[]
+        val=[]
+
+        myval = self.get_river_values_op(which_value, which_group, operator)
+
+        for curkey, curval in myval.items():
+            if len(curval)>0 and which_sim in curval.keys():
+                val.append(curval[which_sim])
+                s.append(self.polygons_curvi[curkey])
+
+        # Tri des valeurs selon l'absisse curviligne
+        ret = sorted(zip(s, val))
+
+        # Séparation des listes triées
+        s, val = zip(*ret)
+        
+        return s, val
+
+    
     def plot_unk(self,
                  figax = None,
                  which_value:Union[stored_values_unk,stored_values_pos]=stored_values_unk.WATERLEVEL,
@@ -448,6 +719,7 @@ class Polygons_Analyze(Zones):
                  options:dict=None,
                  label=True,
                  show=False):
+        """ Plot the values of the river polygons """
 
         if figax is None:
             fig,ax = plt.subplots(1,1)
@@ -528,6 +800,7 @@ class Polygons_Analyze(Zones):
                        which_group=None,
                        operator:operators=operators.MEDIAN,
                        show=False):
+        """ Plot the waterline """
 
         fig,ax = self.plot_unk(figax, stored_values_unk.TOPOGRAPHY, which_group, operator, options={'color':'black', 'linewidth':2}, label=False, show=False)
         figax=(fig,ax)
@@ -547,6 +820,7 @@ class Polygons_Analyze(Zones):
                        which_group=None,
                        operator:operators=operators.MEDIAN,
                        show=False):
+        """ Plot the bed elevation """
 
         fig,ax = self.plot_unk(figax, stored_values_unk.TOPOGRAPHY, which_group, operator, options={'color':'black', 'linewidth':2}, label=False, show=False)
 
@@ -563,6 +837,7 @@ class Polygons_Analyze(Zones):
                        which_group=None,
                        operator:operators=operators.MEDIAN,
                        show=False):
+        """ Plot the water stage /water level """
 
         fig,ax = self.plot_unk(figax, stored_values_unk.WATERLEVEL, which_group, operator, options={'color':'blue', 'linewidth':2}, show=False)
 
@@ -579,6 +854,7 @@ class Polygons_Analyze(Zones):
                        which_group=None,
                        operator:operators=operators.MEDIAN,
                        show=False):
+        """ Plot the water head """
 
         fig,ax = self.plot_unk(figax, stored_values_unk.HEAD, which_group, operator, options={'color':'blue', 'linewidth':2}, show=False)
 

wolfhece/report/reporting.py

@@ -0,0 +1,479 @@
+
+from docx import Document
+from docx.shared import Pt
+from docx.oxml.ns import qn
+from docx.shared import Inches
+from docx.shared import RGBColor
+from pathlib import Path
+from typing import Union, List, Tuple,Literal
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+from PIL import Image
+import pandas as pd
+from tempfile import NamedTemporaryFile, TemporaryDirectory
+import logging
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+from datetime import datetime
+import os
+import socket
+import hashlib
+
+from gettext import gettext as _
+
+class RapidReport:
+    """ 
+    Class for creating a report 'quickly'.
+
+    It can be used in Jupyter notebooks or in scripts to create a simple report in Word format.
+
+    Word document is created with the following structure:
+
+    - Main page with title, author, date and hash of the document
+    - Summary (automatically generated)
+    - Title
+    - Paragraph
+    - Figure (numbered automatically with caption)
+    - Bullet list
+    - Table
+
+    It is not a full-fledged reporting tool with advanced functionnalities but a simple way to create a report quickly 'on-the-fly'.
+
+    
+    Example:
+
+    ```
+    rapport = RapidReport('Rapport de Projet', 'Alice')
+
+    rapport.add_title('Titre Principal', level=0)
+    rapport.add_paragraph('Ceci est un **paragraphe** introductif avec des mots en *italique* et en **gras**.')
+
+    rapport += "Tentative d'ajout de figure vie un lien incorrect.\nPassage à la ligne"
+    rapport.add_figure('/path/to/image.png', 'Légende de la figure.')
+
+    rapport.add_bullet_list(['Premier élément', 'Deuxième élément', 'Troisième élément'])
+
+    rapport.add_table_from_listoflists([['Nom', 'Âge'], ['Alice', '25'], ['Bob', '30']])
+
+    rapport.save('rapport.docx')
+    ```
+
+    """
+
+    def __init__(self, main_title:str, author:str):
+        
+        self._main_title = None
+        self._author = None
+        self._date = None
+
+        self._content = []
+        self._document = Document()
+
+        self._filename = None
+
+        self._idx_figure = 0
+
+        self._styles={}
+        self.define_default_styles()
+
+        self._has_first_page = False
+        self.fill_first_page(main_title, author)
+ 
+    def define_default_styles(self):
+        
+        # Définir le style de titre
+        self._title_style = self._document.styles.add_style('TitleStyle', 1)
+        self._title_style.font.name = 'Arial'
+        self._title_style.font.size = Pt(20)
+        self._title_style.font.bold = True
+        self._title_style._element.rPr.rFonts.set(qn('w:eastAsia'), 'Arial')
+ 
+        # Définir le style de légende
+        self._caption_style = self._document.styles.add_style('CaptionStyle', 1)
+        self._caption_style.font.name = 'Arial'
+        self._caption_style.font.size = Pt(10)
+        self._caption_style.font.italic = True
+        self._caption_style._element.rPr.rFonts.set(qn('w:eastAsia'), 'Arial')
+        self._caption_style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+ 
+        # Définir le style de corps de texte
+        self._body_text_style = self._document.styles.add_style('BodyTextStyle', 1)
+        self._body_text_style.font.name = 'Arial'
+        self._body_text_style.font.size = Pt(12)
+        self._body_text_style._element.rPr.rFonts.set(qn('w:eastAsia'), 'Arial')
+
+        # Définir le style de liste à puce
+        self._bullet_list_style = self._document.styles.add_style('BulletListStyle', 1)
+        self._bullet_list_style.font.name = 'Arial'
+        self._bullet_list_style.font.size = Pt(12)
+        self._bullet_list_style._element.rPr.rFonts.set(qn('w:eastAsia'), 'Arial')
+        self._bullet_list_style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
+        self._bullet_list_style.paragraph_format.left_indent = Inches(0.25)
+
+        self._table_grid_style = self._document.styles.add_style('TableGrid', 3)
+        self._table_grid_style.font.name = 'Arial'
+        self._table_grid_style.font.size = Pt(10)
+        self._table_grid_style._element.rPr.rFonts.set(qn('w:eastAsia'), 'Arial')
+        self._table_grid_style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+        self._figure_style = self._document.styles.add_style('FigureStyle', 1)
+        self._figure_style.font.name = 'Arial'
+        self._figure_style.font.size = Pt(10)
+        self._figure_style._element.rPr.rFonts.set(qn('w:eastAsia'), 'Arial')
+        self._figure_style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+        self._styles['TitleStyle'] = self._title_style
+        self._styles['CaptionStyle'] = self._caption_style
+        self._styles['BodyTextStyle'] = self._body_text_style
+        self._styles['BulletListStyle'] = self._bullet_list_style
+        self._styles['TableGrid'] = self._table_grid_style
+        self._styles['FigureStyle'] = self._figure_style
+
+    def set_font(self, fontname:str='Arial', fontsize:int=12):
+        """ Définir la police et la taille de la police pour les styles de texte. """
+
+        for style in self._styles.values():
+            style.font.name = fontname
+            style.font.size = Pt(fontsize)
+
+    def fill_first_page(self, main_title:str, author:str):
+        """ 
+        Remplir la première page du document. 
+        
+        Ajouter le titre, l'auteur et la date.
+        
+        """
+
+        # Récupérer le nom de l'utilisateur
+        user_name = os.getlogin()
+
+        # Récupérer le nom de l'ordinateur
+        computer_name = socket.gethostname()
+
+        logo_path = Path(__file__).parent / 'wolf_report.png'
+
+        self._main_title = main_title
+        self._author = author
+        self._date = datetime.now().strftime('%d/%m/%Y')
+
+        self._document.add_heading(self._main_title, level=0)
+        self.add_figure(logo_path,caption=None, width=2.0)
+
+        self.add_paragraph('Ce document a été généré automatiquement par le paquet Python "wolfhece".')
+        self.add_paragraph(' ')
+        self.add_paragraph(f'Auteur : {self._author}')
+        self.add_paragraph(f'Date : {self._date}')
+        self.add_paragraph(' ')
+        self.add_paragraph(f'Utilisateur : {user_name}')
+        self.add_paragraph(f'Ordinateur : {computer_name}')
+        self.add_paragraph(' ')
+
+        chain_hash = hashlib.md5(self._main_title.encode() + 
+                                 self._author.encode() +
+                                 user_name.encode() + 
+                                 computer_name.encode()+
+                                 self._date.encode()).hexdigest()
+        
+        self.add_paragraph('Hash du document : ' + chain_hash)
+
+        self.add_new_page()
+
+        self.add_paragraph('summary')
+
+        self._has_first_page = True
+
+    def add_title(self, title:str, level:int=1):
+        """ Ajoute un titre au document. """
+        
+        self._content.append(('title', title, level))
+
+    def _list_titles(self, level:int=None):
+        """ Renvoie la liste des titres du document. """
+
+        if level is None:
+            return [item[1] for item in self._content if item[0] == 'title']
+        else:
+            return [item[1] for item in self._content if item[0] == 'title' and item[2] == level]
+        
+    def _list_captions(self):
+        """ Renvoie la liste des légendes de figures du document. """
+
+        return [item[2] for item in self._content if item[0] == 'figure' if item[2]]
+
+    def _list_figures(self):
+        """ Renvoie la liste des figures du document. """
+
+        return [item[1] for item in self._content if item[0] == 'figure' if item[1] and item[2]]
+
+    def _list_index(self):
+        """ Renvoie la liste des index de figures du document. """
+
+        return [item[3] for item in self._content if item[0] == 'figure' if item[3]]
+    
+    def fig_exists(self, fig_name:str):
+        """ Vérifie si une figure existe dans le document. """
+
+        return fig_name in self._list_figures()
+    
+    def get_fig_index(self, fig_name_caption:str):
+        """ Renvoie la légende d'une figure. """
+
+        list_figures = self._list_figures()
+        list_captions = self._list_captions()
+
+        if fig_name_caption in list_figures:
+            idx = self._list_figures().index(fig_name_caption)+1
+        elif fig_name_caption in list_captions:
+            idx = self._list_captions().index(fig_name_caption)+1
+        else:
+            idx = None
+
+        return idx
+    
+    def _add_summary(self):
+        """ Ajoute un sommaire au document. """
+
+        titles = self._list_titles()
+        
+        self._document.add_heading(_('Summary'), level=1).style = 'TitleStyle'
+    
+        for cur_title in titles:
+            p = self._document.add_paragraph(cur_title, style='BodyTextStyle')
+            run = p.add_run()
+            run.add_tab()
+            run.bold = True
+            p.style = 'BodyTextStyle'
+        
+        self._document.add_heading(_('List of figures'), level=1).style = 'TitleStyle'
+        figures = self._list_captions()
+        for i, cur_figure in enumerate(figures):
+            p = self._document.add_paragraph(f'Fig. {i+1} : {cur_figure}', style='BodyTextStyle')
+            run = p.add_run()
+            run.add_tab()
+            run.bold = True
+            p.style = 'BodyTextStyle'
+
+        self._document.add_page_break()
+ 
+    def add_paragraph(self, paragraph_text:str, style:str='BodyTextStyle'):
+        """ Ajoute un paragraphe au document. """
+
+        self._content.append(('paragraph', paragraph_text, style))
+ 
+    def add(self, paragraph_text:str, style:str='BodyTextStyle'):
+        """ Ajoute un paragraphe au document. """
+
+        self.add_paragraph(paragraph_text, style=style)
+
+    def __add__(self, paragraph_text:str):
+        """ Surcharge de l'opérateur + pour ajouter un paragraphe. """
+
+        self.add_paragraph(paragraph_text)
+
+        return self
+
+    def add_figure(self, image_path:Union[str,Path,Image.Image], caption:str, width:float=7.0):
+        """ Ajoute une figure au document avec une légende. """
+
+        if caption:
+            self._idx_figure += 1
+        
+        self._content.append(('figure', image_path, caption, width, self._idx_figure))
+
+    def add_bullet_list(self, bullet_list: List[str], style:str='BulletListStyle'):
+        """ Ajoute une liste à puce au document. """
+
+        for item in bullet_list:
+            self.add_paragraph('- ' + item, style=style)
+
+    def add_new_page(self):
+        """ Ajoute une nouvelle page au document. """
+
+        self._content.append(('newpage', '', None))
+    
+    def add_table_from_listoflists(self, data:List[List[str]], style:str='TableGrid'):
+        """ 
+        Ajoute un tableau au document. 
+        
+        :param data: Liste de listes contenant les données du tableau. Chaque liste est une ligne du tableau.
+
+        """
+
+        self._content.append(('table', data, style))
+
+    def add_table_from_dict(self, data:dict, style:str='TableGrid'):
+        """ 
+        Ajoute un tableau au document. 
+        
+        :param data: Dictionnaire contenant les données du tableau. Les clés sont les en-têtes de colonnes.
+
+        """
+
+        table_data = [list(data.keys())]
+        table_data += [list(data.values())]
+        self.add_table_from_listoflists(table_data, style=style)
+
+    def add_table_as_picture(self, data:Union[List[List[str]], dict, pd.DataFrame, Figure], caption:str=None):
+        """ Ajoute un tableau au document sous forme d'image. """
+
+        def fig2img(fig):
+            """Convert a Matplotlib figure to a PIL Image and return it"""
+            import io
+            buf = io.BytesIO()
+            
+            fig.savefig(buf, bbox_inches='tight')
+            buf.seek(0)
+            img = Image.open(buf)
+            return img        
+
+        if isinstance(data, Figure):
+            tmp_image = fig2img(data)
+            self.add_figure(tmp_image, caption)
+            return
+        
+        if isinstance(data, dict):
+            data = pd.DataFrame(data)
+        elif isinstance(data, list):
+            data = pd.DataFrame(data)
+
+        fig, ax = plt.subplots()
+
+        ax.axis('off')
+        ax.table(cellText=data.values, 
+                 colLabels=data.columns, 
+                 loc='center', 
+                 cellLoc='center', 
+                 colColours=['#f3f3f3']*len(data.columns))
+        
+        fig.tight_layout()
+        
+        tmp_image = fig2img(fig)
+
+        self.add_figure(tmp_image, caption, width=4.0)
+
+    def _apply_text_styles(self, paragraph, text):
+        """ Search for bold and italic styles in the text and apply them."""
+
+        def split_bold(text):
+            return text.split('**')
+        
+        def split_italic(text):
+            return text.split('*')
+        
+        splitted_bold = split_bold(text)
+
+        bold = False
+        for cur_text in splitted_bold:
+            if cur_text != '':
+                italic = False
+                spliited_italic = split_italic(cur_text)
+                for cur_text2 in spliited_italic:
+                    if cur_text2 != '':
+                        run = paragraph.add_run(cur_text2)
+                        run.bold = bold
+                        run .italic = italic
+                    
+                    italic = not italic
+            bold = not bold
+ 
+    def parse_content(self):
+        """ Parse le contenu du document et l'ajoute au document Word. """
+
+        # tmp_dir = TemporaryDirectory()
+
+        for item in self._content:
+
+            if item[0] == 'title':
+                self._document.add_heading(item[1], level=item[2]).style = 'TitleStyle'
+            
+            elif item[0] == 'paragraph':
+
+                if item[1] == 'summary':
+                    self._add_summary()
+                    continue
+                else:
+                    p = self._document.add_paragraph()
+                    self._apply_text_styles(p, item[1])
+                    p.style = item[2] if item[2] else 'BodyTextStyle'
+            
+            elif item[0] == 'figure':
+
+                if isinstance(item[1], Image.Image):
+                    
+                    tmp_name = NamedTemporaryFile(suffix='.png').name
+                    item[1].save(tmp_name)
+
+                elif isinstance(item[1], str):
+                    tmp_name = item[1]
+
+                elif isinstance(item[1], Path):
+                    tmp_name = str(item[1])
+
+                if Path(tmp_name).exists():
+                    self._document.add_picture(tmp_name, width=Inches(item[3]) if item[3] else Inches(7.0))
+                    self._document.paragraphs[-1].style = 'FigureStyle'
+                else:
+                    logging.error(f"File {tmp_name} not found.")
+                    p = self._document.add_paragraph()
+                    run = p.add_run(f'Error: Image not found. {tmp_name}')
+                    run.font.color.rgb = RGBColor(255, 0, 0)
+                    p.style = 'BodyTextStyle'
+
+                if item[2]:
+                    caption = self._document.add_paragraph(f'Fig. {item[4]} :' + item[2])
+                    caption.style = 'CaptionStyle'
+
+            elif item[0] == 'table':
+                
+                data = item[1]
+                style = item[2]
+                table = self._document.add_table(rows=len(data), cols=len(data[0]))
+                table.style = style
+
+                for i, row in enumerate(data):
+                    for j, cell in enumerate(row):
+                        table.cell(i, j).text = cell
+
+            elif item[0] == 'newpage':
+                self._document.add_page_break()
+ 
+    def save(self, file_path:Union[str,Path]=None):
+        """ Sauvegarde le document Word. """
+        
+        if file_path is None:
+            file_path = self._filename
+
+        if file_path is None:
+            raise ValueError("Le chemin du fichier n'a pas été spécifié.")
+
+        self.parse_content()
+        try:
+            self._document.save(str(file_path))
+        except Exception as e:
+            logging.error(f"Error saving file: {e}")
+ 
+if __name__ == '__main__':
+
+    # Exemple d'utilisation
+    rapport = RapidReport('Rapport de Projet', 'Alice')
+
+    rapport.add_title('Titre Principal', level=0)
+    rapport.add_paragraph('Ceci est un **paragraphe** introductif avec des mots en *italique* et en **gras**.')
+    
+    rapport += "Tentative d'ajout de figure vie un lien incorrect.\nPassage à la ligne"
+    rapport.add_figure('/path/to/image.png', 'Légende de la figure.')
+    rapport+=""" 
+Commentraire sur la figure multilignes
+ligne 2
+ligne3"""
+
+    rapport.add_bullet_list(['Premier élément', 'Deuxième élément', 'Troisième élément'])
+    
+    rapport.add_table_from_listoflists([['Nom', 'Âge'], ['Alice', '25'], ['Bob', '30']])
+    rapport.add_table_from_dict({'Nom': ['Alice', 'Bob'], 'Âge': ['25', '30']})
+    rapport.add_table_as_picture({'Nom': ['Alice', 'Bob'], 'Âge': ['25', '30']}, caption='Tableau de données')
+
+    rapport.save('rapport.docx')
+
+    assert rapport.get_fig_index('/path/to/image.png') == 1
+    assert rapport.get_fig_index('Tableau de données') == 2
+

{wolfhece-2.1.7.dist-info → wolfhece-2.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.7
+Version: 2.1.9
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: AGPL-v3 License
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.1.7.dist-info → wolfhece-2.1.9.dist-info}/RECORD

@@ -11,7 +11,7 @@ wolfhece/PyGui.py,sha256=VKE785z9XLIWNbxqpyEceLK_wtmPJyq6A_M_qX_94Lg,104772
 wolfhece/PyGuiHydrology.py,sha256=wKhR-KthPRyzJ887NmsozmUpm2CIQIwO3IbYORCYjrE,7290
 wolfhece/PyHydrographs.py,sha256=GKK8U0byI45H9O_e4LAOOi7Aw0Tg7Q0Lx322stPg5IQ,3453
 wolfhece/PyPalette.py,sha256=_Nm2Lc4UxYlZgK8ifZDioG8a0at8oiteYC0x_4XugFc,24384
-wolfhece/PyParams.py,sha256=361iy9b9zTjoPCj9gh8-OIo0TBW5laLG87AkWE6f_eg,96290
+wolfhece/PyParams.py,sha256=963fkDSEadlLLxe7WM4Nl6nLOeZsOWSFmfg7hIsWPU4,96785
 wolfhece/PyPictures.py,sha256=-mJB0JL2YYiEK3D7_ssDkvYiMWK4ve9kXhozQXNeSx8,2216
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=dHTjyYYTn0F_NWerlAOBKHV79RUzEEtMJMldQtVc1Cs,40092
@@ -34,13 +34,13 @@ wolfhece/import_ascfiles.py,sha256=jg4urcLdSgFS1Knvh7AVGJqM44qc_uYDNrR568tMh-A,4
 wolfhece/ins.py,sha256=0aU1mo4tYbw64Gwzrqbh-NCTH1tukmk0mpPHjRPHZXU,12661
 wolfhece/irm_qdf.py,sha256=749SlAXiN1oXp5tfBJoPNJWxydQlY55K0qvIM5YexlM,15436
 wolfhece/ismember.py,sha256=fkLvaH9fhx-p0QrlEzqa6ySO-ios3ysjAgXVXzLgSpY,2482
-wolfhece/multiprojects.py,sha256=DdObaugeNrd2I7rtWd6M5W0nVXN8KRVmcXLjMg9oqYs,15795
+wolfhece/multiprojects.py,sha256=tHrAdOBoEEsuNS8hV7udbvduOZLj_NqF3ee5hSDBhN8,20903
 wolfhece/picc.py,sha256=KKPNk1BEe7QBzo2icIsdsxUopJ1LXYTomfdfeG2gCeA,7419
 wolfhece/pyGui1D.py,sha256=pzLWXQ_w3Y_yI846w1GklFO9h5lWZOqiUzg1BUPkuRI,121616
-wolfhece/pybridges.py,sha256=HJ1BL1HC7UrgpQ-3jKXkqPFmc-TzToL28Uex2hjHk6c,57166
+wolfhece/pybridges.py,sha256=4PRSsWngDmQnlVuN2tJj0C_HT1h47ExH9QTUPs_Wxlg,57215
 wolfhece/pydike.py,sha256=G4jfSZaAHHr4VWEJqnXSvEswXvlOz1yhbhQ6uu3AqyM,1943
 wolfhece/pylogging.py,sha256=i9Zugx3t9dPc7nBwcP20L_R4_k_WawpAQsvbZU8l9Hg,4230
-wolfhece/pypolygons_scen.py,sha256=BAo1tg8rJGkmKlEyTbb8gnofk-aPbrKunE2-0YWNaHQ,26581
+wolfhece/pypolygons_scen.py,sha256=Zqr_vs--QEKRSxG-SfduqSR0aPT5rM3BRxmXTOSh2Iw,37146
 wolfhece/pyshields.py,sha256=YS6VVjjzoA-ZR6YRccqjMcW3McNqNLoQODC6TNNkmPw,22983
 wolfhece/pyviews.py,sha256=hYdyrEvWF48dGBDOLIwmC28C0L8I28U4ohXk9nltF94,9666
 wolfhece/pywalous.py,sha256=GRS5TKoVT0J-3PBqMdlyFRHrqkdYC-uHgDPcMjoDEZw,18674
@@ -66,7 +66,7 @@ wolfhece/apps/check_install.py,sha256=jrKR-njqnpIh6ZJqvP6KbDUPVCfwTNQj4glQhcyzs9
 wolfhece/apps/curvedigitizer.py,sha256=avWERHuVxPnJBOD_ibczwW_XG4vAenqWS8W1zjhBox8,4898
 wolfhece/apps/isocurrent.py,sha256=4XnNWPa8mYUK7V4zdDRFrHFIXNG2AN2og3TqWKKcqjY,3811
 wolfhece/apps/splashscreen.py,sha256=LkEVMK0eCc84NeCWD3CGja7fuQ_k1PrZdyqD3GQk_8c,2118
-wolfhece/apps/version.py,sha256=QnnuNPQqjbCKaqce2cE43Ky9-bjQgDRUR3St4eC7HII,387
+wolfhece/apps/version.py,sha256=FOnRXwi0LTd0u8m3r5Ap-8eX-pLzJQIG3E9iImOCttA,387
 wolfhece/apps/wolf.py,sha256=gqfm-ZaUJqNsfCzmdtemSeqLw-GVdSVix-evg5WArJI,293
 wolfhece/apps/wolf2D.py,sha256=gWD9ee2-1pw_nUxjgRaJMuSe4kUT-RWhOeoTt_Lh1mM,267
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -241,6 +241,9 @@ wolfhece/radar/wolfradar.py,sha256=ylyz8hNAGq92WXnMO8hVe6Nk-a7g--fL-xOcjfhFEtk,9
 wolfhece/rem/REMMaker.py,sha256=kffClHHpf8P4ruZpEb9EB__HBzg9rFAkiVCh-GFtIHU,30790
 wolfhece/rem/RasterViz.py,sha256=TDhWyMppcYBL71HfhpZuMgYKhz7faZg-MEOQJo_3Ivo,29128
 wolfhece/rem/__init__.py,sha256=S2-J5uEGK_VaMFjRUYFIdSScJjZyuXH4RmMmnG3OG7I,19
+wolfhece/report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wolfhece/report/reporting.py,sha256=ptsObq4hrVc1b_cfu2ISL6oesSsBphk03QtFnr8E9hc,17565
+wolfhece/report/wolf_report.png,sha256=NoSV58LSwb-oxCcZScRiJno-kxDwRdm_bK-fiMsKJdA,592485
 wolfhece/scenario/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/scenario/check_scenario.py,sha256=nFiCscEGHyz1YvjmZoKlYrfmW03-nLiDTDdRoeE6MUs,4619
 wolfhece/scenario/config_manager.py,sha256=SValpikuNt_XaJXt8P7kAu6iN_N5YlohyL8ry3iT380,77389
@@ -264,8 +267,8 @@ wolfhece/sounds/sonsw2.wav,sha256=pFLVt6By0_EPQNt_3KfEZ9a1uSuYTgQSX1I_Zurv9Rc,11
 wolfhece/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=yGbU_JsF56jsmms0gh7mxa7tbNQ_SxqhpAZxhm-mTy4,14860
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=wCxGRnE3kzEkWlWA6-3X8ADOFux_B0a5QWJ2GnXTgJw,4709
-wolfhece-2.1.7.dist-info/METADATA,sha256=tv3E_t--2aA71zEbF4xRjwE3klu3AAVpHUIzRBLFVH8,2281
-wolfhece-2.1.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-wolfhece-2.1.7.dist-info/entry_points.txt,sha256=AIu1KMswrdsqNq_2jPtrRIU4tLjuTnj2dCY-pxIlshw,276
-wolfhece-2.1.7.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.7.dist-info/RECORD,,
+wolfhece-2.1.9.dist-info/METADATA,sha256=kTZzCdCRgXrjJ2HsS_7YS8fXP8zYlxvXNigdrYepDqg,2281
+wolfhece-2.1.9.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+wolfhece-2.1.9.dist-info/entry_points.txt,sha256=AIu1KMswrdsqNq_2jPtrRIU4tLjuTnj2dCY-pxIlshw,276
+wolfhece-2.1.9.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.9.dist-info/RECORD,,

{wolfhece-2.1.7.dist-info → wolfhece-2.1.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any