wolfhece 2.2.31__py3-none-any.whl → 2.2.32__py3-none-any.whl

wolfhece/analyze_poly.py

@@ -35,6 +35,14 @@ class Array_analysis_onepolygon():
         self._selected_cells = None
         self._values = None
 
+    @ property
+    def centroid(self) -> Point:
+        """ Get the centroid of the polygon as a Point object.
+
+        :return: Shapely Point object representing the centroid of the polygon
+        """
+        return self._polygon.centroid
+
     def values(self, which:Literal['Mean', 'Std', 'Median', 'Sum', 'Volume', 'Values', 'Area']) -> pd.DataFrame | float:
         """ Get the values as a pandas DataFrame
 
@@ -59,6 +67,25 @@ class Array_analysis_onepolygon():
         else:
             return self._values[which]
 
+    def as_vector(self, add_values:bool = True):
+        """ Return a copy of the polygon with the values as attributes. """
+
+        newvec = self._polygon.deepcopy()
+
+        if add_values:
+            if self._values is None:
+                self.compute_values()
+                self._add_area2velues()
+
+            if self._values is None:
+                raise ValueError("No values computed. Please call compute_values() first.")
+
+            for key, value in self._values.items():
+                newvec.add_value(key, value)
+
+        newvec.myname = self._polygon.myname
+        return newvec
+
     def select_cells(self, mode:Literal['polygon', 'buffer'] = 'polygon', **kwargs):
         """Select the cells inside the polygon.
 
@@ -127,8 +154,13 @@ class Array_analysis_onepolygon():
                 raise ValueError("No polygon provided. Please provide a polygon to select cells.")
 
             self._values['Area'] = self._polygon.area
+            centroid = self._polygon.centroid
+            self._values['X'] = centroid.x
+            self._values['Y'] = centroid.y
         else:
             self._values['Area'] = len(self._selected_cells) * self._wa.dx * self._wa.dy
+            self._values['X'] = np.mean(self._selected_cells[:, 0])
+            self._values['Y'] = np.mean(self._selected_cells[:, 1])
 
     @property
     def n_selected_cells(self) -> int:
@@ -278,6 +310,17 @@ class Array_analysis_polygons():
 
         self._active_categories = self.all_categories
 
+    def as_zone(self, add_values:bool = True) -> zone:
+        """ Convert the analysis to a zone of polygons """
+
+        ret_zone = zone(name=self._polygons.myname)
+        for name, poly in self._zone.items():
+            if name.split('___')[0] in self._active_categories:
+                if poly.has_values:
+                    ret_zone.add_vector(poly.as_vector(add_values), forceparent=True)
+
+        return ret_zone
+
     @property
     def _areas(self) -> list[float]:
         """ Get the areas of the polygons in the zone """
@@ -357,6 +400,36 @@ class Array_analysis_polygons():
         lst = [pol.values('Values') for key, pol in self._zone.items() if pol.has_values and key.split('___')[0] in self._active_categories]
         return pd.concat(lst, axis=1)
 
+    def get_geometries(self) -> pd.DataFrame:
+        """ Get the centroids of all polygons in the zone as a pandas DataFrame.
+
+        :return: pandas DataFrame with the centroids of the polygons
+        """
+        centroids = {key: {'Centroid' : poly.centroid, 'X': poly.centroid.x, 'Y' : poly.centroid.y, 'Geometry': poly._polygon.polygon} for key, poly in self._zone.items() if poly.has_values and key.split('___')[0] in self._active_categories}
+        return pd.DataFrame.from_dict(centroids, orient='index')
+
+    def get_geodataframe_with_values(self, epsg:int = 31370) -> 'gpd.GeoDataFrame':
+        """ Create a GeoDataFrame with the centroids and values of the polygons.
+
+        Values are added as a column named 'Values' as Numpy array."""
+
+        import geopandas as gpd
+
+        geom = self.get_geometries()
+        # Add values as numpy arrays to the DataFrame
+        geom['Values'] = None
+        geom['Values'] = geom['Values'].astype(object)
+
+        # Get values for each polygon and add them to the DataFrame
+        for key, poly in self._zone.items():
+            if poly.has_values and key.split('___')[0] in self._active_categories:
+                values = poly.values('Values')
+                geom.at[key, 'Values'] = values.to_numpy().ravel()
+
+        # Create a GeoDataFrame
+        gdf = gpd.GeoDataFrame(geom, geometry='Geometry', crs=f'EPSG:{epsg}')
+        return gdf
+
     @property
     def polygons(self) -> zone:
         """ Get the zone of polygons """
@@ -510,6 +583,40 @@ class Array_analysis_polygons():
 
         return fig
 
+    def clustering(self, n_clusters:int = 5, operator:Literal['Mean', 'Median', 'Sum', 'Volume', 'Area'] = 'Mean'):
+        """ Perform clustering on the polygons based on their values. """
+        from sklearn.cluster import KMeans
+        import geopandas as gpd
+
+        # Get the values of the polygons
+        values = self.values(operator)
+        geometries = self.get_geodataframe_with_values()
+
+        xy = geometries[['X', 'Y']].copy()
+
+        if values.empty:
+            raise ValueError("No values to cluster. Please compute values first.")
+
+        # Perform clustering
+        kmeans = KMeans(n_clusters=n_clusters)
+
+        kmeans.fit(xy[['X', 'Y']].values)
+        labels = kmeans.labels_
+        geometries['Cluster'] = labels
+
+        centroids = kmeans.cluster_centers_
+        cluster_centroids = [Point(xy) for xy in centroids]
+
+        # Find footprints of the clusters
+        footprints = []
+        for label in np.unique(labels):
+            geom_cluster = geometries[geometries['Cluster'] == label]
+            footprint = geom_cluster.geometry.unary_union.convex_hull
+            footprints.append(footprint)
+
+        return geometries, (cluster_centroids, footprints)
+
+
 class Array_analysis_zones():
     """ Class for values analysis of an array based on a Zones instance.
 
@@ -524,6 +631,16 @@ class Array_analysis_zones():
 
         self._polygons = {zone.myname: Array_analysis_polygons(self._wa, zone, buffer_size) for zone in self._zones.myzones if zone.used}
 
+    def as_zones(self, add_values:bool = True) -> Zones:
+        """ Convert the analysis to a Zones instance """
+
+        newzones = Zones(idx=self._zones.idx)
+        for name, pol in self._polygons.items():
+            newzones.add_zone(pol.as_zone(add_values), forceparent=True)
+
+        return newzones
+
+
     def __getitem__(self, key:str) -> Array_analysis_polygons:
         """ Get the zone by name """
         if key in self._polygons:
@@ -623,6 +740,46 @@ class Arrays_analysis_zones():
         self._active_categories = self.all_categories
         self._active_arrays = self.all_arrays
 
+    def __getitem__(self, key:str | tuple) -> Array_analysis_polygons:
+        """ Get the zone by name """
+        if isinstance(key, tuple):
+            if len(key) != 2:
+                raise ValueError("Key must be a tuple of (zone_name, array_name).")
+            zone_name, array_name = key
+            if zone_name not in self._polygons or array_name not in self._polygons[zone_name]:
+                raise KeyError(f"Zone {zone_name} or array {array_name} not found in zones.")
+            return self._polygons[zone_name][array_name]
+
+        elif isinstance(key, str):
+            if len(self._polygons) == 1:
+                # If there is only one zone, return the first array in that zone
+                zone_name = next(iter(self._polygons))
+                if key in self._polygons[zone_name]:
+                    return self._polygons[zone_name][key]
+                else:
+                    raise KeyError(f"Array {key} not found in the only zone available.")
+            else:
+                if key in self._polygons:
+                    return self._polygons[key]
+                else:
+                    raise KeyError(f"Zone {key} not found in zones.")
+
+    def as_zones(self, add_values:bool = True) -> Zones:
+        """ Convert the analysis to a Zones instance """
+
+        newzones = Zones(idx=self._zones.idx)
+        for name, dct in self._polygons.items():
+            for array_name, pols in dct.items():
+                if array_name not in self._active_arrays:
+                    continue
+
+                newzone = pols.as_zone(add_values)
+                newzone.myname = f"{array_name}"
+
+                newzones.add_zone(newzone, forceparent=True)
+
+        return newzones
+
     @property
     def _areas(self) -> dict[str, list[float]]:
         """ Get the areas of the polygons in the zones """
@@ -1173,8 +1330,8 @@ class Building_Waterdepth_analysis(Arrays_analysis_zones):
 
         if merge_zones:
             # copy all vectors in an unique zone
-            newz = Zones(idx='merged_zones')
-            merged_zone = zone(name='merged_zone')
+            newz = Zones(idx='all')
+            merged_zone = zone(name='all')
             newz.add_zone(merged_zone, forceparent= True)
 
             for z in zones.myzones:

wolfhece/apps/version.py

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

wolfhece/wolf_array.py

@@ -10496,7 +10496,16 @@ class WolfArray(Element_To_Draw, header_wolf):
                         vmin:float=None, vmax:float=None,
                         figsize:tuple=None,
                         Walonmap:bool=False,
-                        cat:str='IMAGERIE/ORTHO_2022_ETE',
+                        cat:Literal['IMAGERIE/ORTHO_1971', 'IMAGERIE/ORTHO_1994_2000', 'IMAGERIE/ORTHO_2006_2007', 'IMAGERIE/ORTHO_2009_2010',
+                                    'IMAGERIE/ORTHO_2012_2013', 'IMAGERIE/ORTHO_2015', 'IMAGERIE/ORTHO_2016',
+                                    'IMAGERIE/ORTHO_2017', 'IMAGERIE/ORTHO_2018', 'IMAGERIE/ORTHO_2019',
+                                    'IMAGERIE/ORTHO_2020', 'IMAGERIE/ORTHO_2021', 'IMAGERIE/ORTHO_2022_PRINTEMPS',
+                                    'IMAGERIE/ORTHO_2022_ETE', 'IMAGERIE/ORTHO_2023_ETE', 'IMAGERIE/ORTHO_LAST',
+                                    'orthoimage_coverage', 'orthoimage_coverage_2016', 'orthoimage_coverage_2017',
+                                    'orthoimage_coverage_2018', 'orthoimage_coverage_2019',
+                                    'orthoimage_coverage_2020', 'orthoimage_coverage_2021',
+                                    'orthoimage_coverage_2022', 'crossborder', 'crossborder_grey',
+                                    'overlay', 'topo', 'topo_grey'] = 'IMAGERIE/ORTHO_LAST',
                         first_mask_data:bool=True,
                         with_legend:bool=False,
                         IGN:bool=False,
@@ -10548,6 +10557,19 @@ class WolfArray(Element_To_Draw, header_wolf):
             - `'IMAGERIE/ORTHO_2022_ETE'`
             - `'IMAGERIE/ORTHO_2023_ETE'`
             - `'IMAGERIE/ORTHO_LAST'`
+            - 'orthoimage_coverage'
+            - 'orthoimage_coverage_2016',
+            - 'orthoimage_coverage_2017',
+            - 'orthoimage_coverage_2018',
+            - 'orthoimage_coverage_2019',
+            - 'orthoimage_coverage_2020',
+            - 'orthoimage_coverage_2021',
+            - 'orthoimage_coverage_2022'
+            - 'crossborder',
+            - 'crossborder_grey',
+            - 'overlay',
+            - 'topo',
+            - 'topo_grey'
         :type cat: str, optional (Default value = `'IMAGERIE/ORTHO_2022_ETE'`)
         :param first_mask_data: If True, applies the mask to the data before plotting. Default is True.
         :type first_mask_data: bool, optional (Default value = True)
@@ -10557,6 +10579,17 @@ class WolfArray(Element_To_Draw, header_wolf):
         :rtype: tuple
         """
 
+        available_Walonmap = ['IMAGERIE/ORTHO_1971', 'IMAGERIE/ORTHO_1994_2000', 'IMAGERIE/ORTHO_2006_2007', 'IMAGERIE/ORTHO_2009_2010',
+                                    'IMAGERIE/ORTHO_2012_2013', 'IMAGERIE/ORTHO_2015', 'IMAGERIE/ORTHO_2016',
+                                    'IMAGERIE/ORTHO_2017', 'IMAGERIE/ORTHO_2018', 'IMAGERIE/ORTHO_2019',
+                                    'IMAGERIE/ORTHO_2020', 'IMAGERIE/ORTHO_2021', 'IMAGERIE/ORTHO_2022_PRINTEMPS',
+                                    'IMAGERIE/ORTHO_2022_ETE', 'IMAGERIE/ORTHO_2023_ETE', 'IMAGERIE/ORTHO_LAST']
+        available_IGN = ['orthoimage_coverage', 'orthoimage_coverage_2016', 'orthoimage_coverage_2017',
+                         'orthoimage_coverage_2018', 'orthoimage_coverage_2019',
+                         'orthoimage_coverage_2020', 'orthoimage_coverage_2021',
+                         'orthoimage_coverage_2022']
+        available_Cartoweb = ['crossborder', 'crossborder_grey', 'overlay', 'topo', 'topo_grey']
+
         if first_mask_data:
             self.mask_data(self.nullvalue)
 
@@ -10572,75 +10605,91 @@ class WolfArray(Element_To_Draw, header_wolf):
             from .PyWMS import getWalonmap
             from PIL import Image
 
-            try:
-                bounds = self.get_bounds()
+            if cat not in available_Walonmap:
+                logging.error(_('The category {} is not available in WalOnMap').format(cat))
+                logging.error(_('Available categories are: {}').format(', '.join(available_Walonmap)))
+            else:
+                try:
+                    bounds = self.get_bounds()
 
-                scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
 
-                if scale_xovery > 1.:
-                    # x is larger than y
-                    w = 2000
-                    h = int(2000 / scale_xovery)
-                else:
-                    # y is larger than x
-                    h = 2000
-                    w = int(2000 * scale_xovery)
+                    if scale_xovery > 1.:
+                        # x is larger than y
+                        w = 2000
+                        h = int(2000 / scale_xovery)
+                    else:
+                        # y is larger than x
+                        h = 2000
+                        w = int(2000 * scale_xovery)
+
+                    IO_image = getWalonmap(cat, bounds[0][0], bounds[1][0],
+                                        bounds[0][1], bounds[1][1],
+                                        w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
 
-                IO_image = getWalonmap(cat, bounds[0][0], bounds[1][0],
-                                       bounds[0][1], bounds[1][1],
-                                       w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
+                    image = Image.open(IO_image)
 
-                image = Image.open(IO_image)
+                    ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
+                except Exception as e:
+                    logging.error(_('Error while fetching the map image from WalOnMap'))
+                    logging.error(e)
 
-                ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
-            except Exception as e:
-                logging.error(_('Error while fetching the map image from WalOnMap'))
-                logging.error(e)
         elif IGN:
             from .PyWMS import getNGI
             from PIL import Image
-            try:
-                bounds = self.get_bounds()
-                scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
-                if scale_xovery > 1.:
-                    # x is larger than y
-                    w = 2000
-                    h = int(2000 / scale_xovery)
-                else:
-                    # y is larger than x
-                    h = 2000
-                    w = int(2000 * scale_xovery)
-                IO_image = getNGI(cat, bounds[0][0], bounds[1][0],
-                                  bounds[0][1], bounds[1][1],
-                                    w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
-                image = Image.open(IO_image)
-                ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
-            except Exception as e:
-                logging.error(_('Error while fetching the map image from IGN'))
-                logging.error(e)
+
+            if cat not in available_IGN:
+                logging.error(_('The category {} is not available in IGN').format(cat))
+                logging.error(_('Available categories are: {}').format(', '.join(available_IGN)))
+
+            else:
+                try:
+                    bounds = self.get_bounds()
+                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    if scale_xovery > 1.:
+                        # x is larger than y
+                        w = 2000
+                        h = int(2000 / scale_xovery)
+                    else:
+                        # y is larger than x
+                        h = 2000
+                        w = int(2000 * scale_xovery)
+                    IO_image = getNGI(cat, bounds[0][0], bounds[1][0],
+                                    bounds[0][1], bounds[1][1],
+                                        w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
+                    image = Image.open(IO_image)
+                    ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
+                except Exception as e:
+                    logging.error(_('Error while fetching the map image from IGN'))
+                    logging.error(e)
 
         elif Cartoweb:
             from .PyWMS import getCartoweb
             from PIL import Image
-            try:
-                bounds = self.get_bounds()
-                scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
-                if scale_xovery > 1.:
-                    # x is larger than y
-                    w = 2000
-                    h = int(2000 / scale_xovery)
-                else:
-                    # y is larger than x
-                    h = 2000
-                    w = int(2000 * scale_xovery)
-                IO_image = getCartoweb(cat, bounds[0][0], bounds[1][0],
-                                        bounds[0][1], bounds[1][1],
-                                        w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
-                image = Image.open(IO_image)
-                ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
-            except Exception as e:
-                logging.error(_('Error while fetching the map image from Cartoweb'))
-                logging.error(e)
+
+            if cat not in available_Cartoweb:
+                logging.error(_('The category {} is not available in Cartoweb').format(cat))
+                logging.error(_('Available categories are: {}').format(', '.join(available_Cartoweb)))
+            else:
+                try:
+                    bounds = self.get_bounds()
+                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    if scale_xovery > 1.:
+                        # x is larger than y
+                        w = 2000
+                        h = int(2000 / scale_xovery)
+                    else:
+                        # y is larger than x
+                        h = 2000
+                        w = int(2000 * scale_xovery)
+                    IO_image = getCartoweb(cat, bounds[0][0], bounds[1][0],
+                                            bounds[0][1], bounds[1][1],
+                                            w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
+                    image = Image.open(IO_image)
+                    ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
+                except Exception as e:
+                    logging.error(_('Error while fetching the map image from Cartoweb'))
+                    logging.error(e)
 
         if vmin is None and vmax is not None:
             vmin = self.mypal.values[0]

{wolfhece-2.2.31.dist-info → wolfhece-2.2.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.31
+Version: 2.2.32
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece

{wolfhece-2.2.31.dist-info → wolfhece-2.2.32.dist-info}/RECORD

@@ -26,7 +26,7 @@ wolfhece/ReadDataDCENN.py,sha256=vm-I4YMryvRldjXTvRYEUCxZsjb_tM7U9yj6OaPyD0k,153
 wolfhece/Results2DGPU.py,sha256=GTu7PMuwfH-xH8J7sVr6zq2CTkGKF24fG1ujEW62PtM,31598
 wolfhece/__init__.py,sha256=EnpZ2yDEXueP7GAKV0uA2vAwMiZFyBjDAFcL5Y7LzbM,1850
 wolfhece/_add_path.py,sha256=mAyu85CQHk0KgUI6ZizweeQiw1Gdyea9OEjGLC6lLA4,916
-wolfhece/analyze_poly.py,sha256=gJlQZ0vwDG_N98eMDtUsLng9kKu-HlJ8a4xER9ubfDc,54527
+wolfhece/analyze_poly.py,sha256=2uNdnRy828jR-aFNg9fx-8aHqXuRAg-hNQpvQ3g2qL8,60837
 wolfhece/analyze_vect.py,sha256=3lkMwaQ4KRddBVRvlP9PcM66wZwwC0eCmypP91AW-os,6015
 wolfhece/cli.py,sha256=h1tSMHALiftktreyugKcjbASXfpJUm9UYMeVxR-MtG4,6424
 wolfhece/color_constants.py,sha256=Snc5RX11Ydi756EkBp_83C7DiAQ_Z1aHD9jFIBsosAU,37121
@@ -61,7 +61,7 @@ wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools2d_dll.py,sha256=TfvvmyZUqEZIH0uHwUCJf0bdmCks_AiidDt23Unsp5w,13550
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=jin9_ntHASNcqMx0CPYFHMEIw-LaF6UnousSaQx3AxU,523441
+wolfhece/wolf_array.py,sha256=_di7NkNjiaKAO5FLqUgxr8XFoAdnOC5B-oLMpf_g270,526959
 wolfhece/wolf_hist.py,sha256=fTEb60Q4TEwobdZsRU4CFXAId1eOKdWAqF8lnF1xEWc,3590
 wolfhece/wolf_texture.py,sha256=f4psYah1vqyeQjXz2O46d6qeKuv_Lzowk39O9Fmh_2g,20969
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
@@ -89,7 +89,7 @@ wolfhece/apps/curvedigitizer.py,sha256=lEJJwgAfulrrWQc-U6ij6sj59hWN3SZl4Yu1kQxVz
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=EdGDN9NhudIiP7c3gVqj7dp4MWFB8ySizM_tpMnsgpE,3091
-wolfhece/apps/version.py,sha256=5D9bE5dzDLfYPyBmgVoMOincHBhGAqYJzByZrRcBiy8,388
+wolfhece/apps/version.py,sha256=YFwBEBJyNYr5L7c5L4vBndUtZOBO27tL7NJgOCGDkW0,388
 wolfhece/apps/wolf.py,sha256=mRnjYsUu4KIsRuamdQWAINFMuwN4eJgMo9erG-hkZ70,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -308,8 +308,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=u4C7CXe_bUyGKx7c_Bi0x9
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.2.31.dist-info/METADATA,sha256=FCE-JySySzwE8OSrK7O7_8IIPOg9RBfBVDS8sPiXfek,2729
-wolfhece-2.2.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wolfhece-2.2.31.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
-wolfhece-2.2.31.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.31.dist-info/RECORD,,
+wolfhece-2.2.32.dist-info/METADATA,sha256=P-q8Ge4qvtiLISYIb4XbpDkwbCdh5KMPx-3k10Xr6qg,2729
+wolfhece-2.2.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wolfhece-2.2.32.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
+wolfhece-2.2.32.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.32.dist-info/RECORD,,