honeybee-radiance-postprocess 0.4.580__py3-none-any.whl → 0.4.582__py3-none-any.whl

honeybee_radiance_postprocess/cli/postprocess.py

@@ -505,6 +505,76 @@ def annual_to_data(
         sys.exit(0)
 
 
+@post_process.command('annual-statistics')
+@click.argument(
+    'folder',
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, resolve_path=True)
+)
+@click.option(
+    '--hoys-file', '-h', help='Path to an HOYs file. Values must be separated by '
+    'new line. If not provided the data will not be filtered by HOYs.',
+    type=click.Path(exists=False, file_okay=True, dir_okay=False, resolve_path=True)
+)
+@click.option(
+    '--states', '-st', help='A JSON file with a dictionary of states. If states '
+    'are not provided the default states will be used for any aperture groups.',
+    default=None, show_default=True,
+    type=click.Path(exists=False, file_okay=True, dir_okay=False, resolve_path=True)
+)
+@click.option(
+    '--grids-filter', '-gf', help='A pattern to filter the grids.', default='*',
+    show_default=True
+)
+@click.option(
+    '--total/--direct', is_flag=True, default=True, help='Switch between total '
+    'and direct results. Default is total.'
+)
+@click.option(
+    '--sensor/--timestep', is_flag=True, default=True, help='Switch between results '
+    'for each sensor or timestep. Default is sensor.'
+)
+
+@click.option(
+    '--sub-folder', '-sf', help='Optional relative path for subfolder to write output '
+    'statistics files.', default='statistics'
+)
+def annual_statistics(
+    folder, hoys_file, states, grids_filter, total, sensor, sub_folder
+):
+    """Get annual statistics (average, median, minimum, maximum, cumulative).
+
+    \b
+    Args:
+        folder: Results folder. This folder is an output folder of annual daylight
+            recipe. Folder should include grids_info.json and sun-up-hours.txt. The
+            command uses the list in grids_info.json to find the result files for each
+            sensor grid.
+    """
+    try:
+        if hoys_file:
+            with open(hoys_file) as hoys:
+                hoys = [float(h) for h in hoys.readlines()]
+        else:
+            hoys = []
+
+        if states:
+            states = DynamicSchedule.from_json(states)
+
+        res_type = 'total' if total is True else 'direct'
+
+        axis = 1 if sensor is True else 0
+
+        results = AnnualDaylight(folder)
+        results.annual_statistics_to_folder(
+            sub_folder, hoys=hoys, states=states, grids_filter=grids_filter,
+            res_type=res_type, axis=axis)
+    except Exception:
+        _logger.exception('Failed to calculate annual statistics.')
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
 @post_process.command('point-in-time')
 @click.argument(
     'folder',
@@ -1030,7 +1100,7 @@ def convert_matrix_to_binary(
         if not comply:
             # this will invert the boolean array
             boolean_array = ~boolean_array
-        
+
         binary_array = boolean_array.astype(int)
         output_file = Path(output_folder, name)
         output_file.parent.mkdir(parents=True, exist_ok=True)

honeybee_radiance_postprocess/metrics.py

@@ -25,7 +25,7 @@ def da_array2d(
         threshold: Threshold value for daylight autonomy. Default: 300.
 
     Returns:
-        A 1-dimensional NumPy array with the daylight autonomy for each row in
+        A 1D NumPy array with the daylight autonomy for each row in
         the input array.
     """
     check_array_dim(array, 2)
@@ -72,7 +72,7 @@ def cda_array2d(
         threshold: Threshold value for continuos daylight autonomy. Default: 300.
 
     Returns:
-        A 1-dimensional NumPy array with the continuos daylight autonomy for
+        A 1D NumPy array with the continuos daylight autonomy for
         each row in the input array.
     """
     check_array_dim(array, 2)
@@ -125,7 +125,7 @@ def udi_array2d(
         max_t: Maximum threshold for useful daylight illuminance. Default: 3000.
 
     Returns:
-        A 1-dimensional NumPy array with the useful daylight illuminance for
+        A 1D NumPy array with the useful daylight illuminance for
         each row in the input array.
     """
     check_array_dim(array, 2)
@@ -178,7 +178,7 @@ def udi_lower_array2d(
         sun_down_occ_hours: Number of occupied hours where the sun is down.
 
     Returns:
-        A 1-dimensional NumPy array with the lower than useful daylight
+        A 1D NumPy array with the lower than useful daylight
         illuminance for each row in the input array.
     """
     check_array_dim(array, 2)
@@ -237,7 +237,7 @@ def udi_upper_array2d(
         max_t: Maximum threshold for useful daylight illuminance. Default: 3000.
 
     Returns:
-        A 1-dimensional NumPy array with the higher than useful daylight
+        A 1D NumPy array with the higher than useful daylight
         illuminance for each row in the input array.
     """
     check_array_dim(array, 2)
@@ -330,20 +330,28 @@ def ase_array2d(
 
 
 def average_values_array2d(
-        array: np.ndarray, full_length: int = 8760) -> np.ndarray:
+        array: np.ndarray, full_length: int = 8760, axis: int = 1) -> np.ndarray:
     """Calculate average values for a 2D NumPy array.
 
+    If axis is 1, the average value for each row is calculated (each sensor). In
+    this case the full length should correspond to the number of timesteps in the
+    analysis.
+
+    If axis is 0, the average value for each column is calculated (each timestep).
+    In this case the full length should correspond to the number of sensors.
+
     Args:
         array: A 2D NumPy array.
         full_length: Integer to use as divisor.
+        axis: Axis along which to compute the average. Default is 1.
 
     Returns:
-        A 1-dimensional NumPy array with the average value for each row in the
-        input array.
+        A 1D NumPy array with the average value for each row or column
+        in the input array.
     """
     check_array_dim(array, 2)
 
-    avg_values = array.sum(axis=1) / full_length
+    avg_values = array.sum(axis=axis) / full_length
 
     return avg_values
 
@@ -365,22 +373,26 @@ def average_values_array1d(
 
 
 def cumulative_values_array2d(
-        array: np.ndarray, timestep: int = 1, t_step_multiplier: float = 1
-        ) -> np.ndarray:
+        array: np.ndarray, timestep: int = 1, t_step_multiplier: float = 1,
+        axis: int = 1) -> np.ndarray:
     """Calculate cumulative values for a 2D NumPy array.
 
     Args:
         array: A 2D NumPy array.
         timestep: Integer for the timestep of the analysis.
         t_step_multiplier: A value that will be multiplied with the timestep.
+        axis: Axis along which to compute the cumulative value. Default is 1.
 
     Returns:
-        A 1-dimensional NumPy array with the cumulative value for each row in
+        A 1D NumPy array with the cumulative value for each row or column
         the input array.
     """
     check_array_dim(array, 2)
 
-    cumulative_values = array.sum(axis=1) / (timestep * t_step_multiplier)
+    if axis == 1:
+        cumulative_values = array.sum(axis=axis) / (timestep * t_step_multiplier)
+    else:
+        cumulative_values = array.sum(axis=axis)
 
     return cumulative_values
 
@@ -416,7 +428,7 @@ def peak_values_array2d(
             at a particular timestep (True).
 
     Returns:
-        A 1-dimensional NumPy array with the peak value for each row in the
+        A 1D NumPy array with the peak value for each row in the
         input array, and the index of the maximum value representing the
         timestep in the array with the largest value.
     """

honeybee_radiance_postprocess/results/results.py

@@ -589,20 +589,8 @@ class Results(_ResultsFolder):
             array = self._array_from_states(grid_info, states=states, res_type=res_type)
             if np.any(array):
                 array_filter = filter_array2d(array, mask=mask)
-                if not hoys:
-                    # concatenate zero array
-                    zero_array = \
-                        np.zeros((grid_info['count'], len(self.sun_down_hours)))
-                    array_filter = np.concatenate((array_filter, zero_array), axis=1)
-                else:
-                    # find number of hoys that are sun down hours
-                    sdh_hoys = \
-                        len(set(self.sun_down_hours).intersection(hoys))
-                    if sdh_hoys != 0:
-                        # concatenate zero array
-                        zero_array = np.zeros((grid_info['count'], sdh_hoys))
-                        array_filter = \
-                            np.concatenate((array_filter, zero_array), axis=1)
+                array_filter = self.pad_array_for_median(
+                    array_filter, hoys, self.sun_down_hours, grid_info['count'])
                 results = np.median(array_filter, axis=1)
             else:
                 results = np.zeros(grid_info['count'])
@@ -809,6 +797,208 @@ class Results(_ResultsFolder):
         info_file = metric_folder.joinpath('grids_info.json')
         info_file.write_text(json.dumps(grids_info))
 
+    def annual_statistics(
+            self, hoys: list = None, states: DynamicSchedule = None, grids_filter: str = '*',
+            res_type: str = 'total', axis: int = 1):
+        """Compute annual statistics (average, median, minimum, maximum,
+        cumulative) for each sensor or timestep.
+
+        If hoys is left as None, the average will be computed for all study hours,
+        i.e., including sun down hours. This will likely lead to low average
+        and median values for a usual annual study.
+
+        Args:
+            hoys: An optional list of numbers to select the hours of the year
+                (HOYs) for which results will be computed.
+            states: A dictionary of states. Defaults to None.
+            grids_filter: The name of a grid or a pattern to filter the grids.
+                Defaults to '*'.
+            res_type: Type of results to load. Defaults to 'total'.
+            axis: Axis along which statistics are computed:
+                - 1: compute per-sensor statistics over time (default)
+                - 0: compute per-timestep statistics across sensors; results are
+                     converted into HourlyContinuousCollection objects.
+
+        Returns:
+            A tuple of the form:
+                (
+                    average_values,
+                    median_values,
+                    minimum_values,
+                    maximum_values,
+                    cumulative_values,
+                    grids_info
+                )
+
+            Where each element except grids_info is a list with one entry per
+            sensor grid:
+                - If axis == 1: each entry is a 1D NumPy array of per-sensor values.
+                - If axis == 0: each entry is an HourlyContinuousCollection.
+
+            grids_info contains metadata for each processed grid.
+        """
+        hoys = [] if hoys is None else hoys
+        grids_info = self._filter_grids(grids_filter=grids_filter)
+        mask = hoys_mask(self.sun_up_hours, hoys)
+
+        analysis_period = AnalysisPeriod(timestep=self.timestep)
+
+        average_values = []
+        median_values = []
+        minimum_values = []
+        maximum_values = []
+        cumulative_values = []
+        for grid_info in grids_info:
+            array = self._array_from_states(grid_info, states=states, res_type=res_type)
+            if np.any(array):
+                array_filter = filter_array2d(array, mask=mask)
+                if axis == 1:
+                    full_length = len(self.study_hours) if not hoys else len(hoys)
+                else:
+                    full_length = grid_info['count']
+                _average_values = average_values_array2d(array_filter, full_length, axis=axis)
+                if axis == 1:
+                    median_array_filter = self.pad_array_for_median(
+                        array_filter, hoys, self.sun_down_hours, grid_info['count'])
+                else:
+                    median_array_filter = array_filter
+                _median_values = np.median(median_array_filter, axis=axis)
+                _minimum_values = np.amin(array_filter, axis=axis)
+                _maximum_values = np.amax(array_filter, axis=axis)
+                _cumulative_values = cumulative_values_array2d(
+                    array_filter, self.timestep, axis=axis)
+            else:
+                if axis == 1:
+                    _average_values = np.zeros(grid_info['count'])
+                    _median_values = np.zeros(grid_info['count'])
+                    _minimum_values = np.zeros(grid_info['count'])
+                    _maximum_values = np.zeros(grid_info['count'])
+                    _cumulative_values = np.zeros(grid_info['count'])
+                else:
+                    _average_values = np.zeros(len(self.sun_up_hours))[mask]
+                    _median_values = np.zeros(len(self.sun_up_hours))[mask]
+                    _minimum_values = np.zeros(len(self.sun_up_hours))[mask]
+                    _maximum_values = np.zeros(len(self.sun_up_hours))[mask]
+                    _cumulative_values = np.zeros(len(self.sun_up_hours))[mask]
+
+            if axis == 0:  # convert values to data collections
+                header = Header(self.datatype, self.unit, analysis_period)
+                header.metadata['Sensor Grid'] = grid_info['full_id']
+                sun_up_hours = np.array(self.sun_up_hours)[mask].ravel()
+
+                annual_array = self.values_to_annual(
+                    sun_up_hours, _average_values, self.timestep)
+                average_header = header.duplicate()
+                average_header.metadata['Metric'] = 'Average'
+                _average_values = HourlyContinuousCollection(average_header, annual_array.tolist())
+
+                annual_array = self.values_to_annual(
+                    sun_up_hours, _median_values, self.timestep)
+                median_header = header.duplicate()
+                median_header.metadata['Metric'] = 'Median'
+                _median_values = HourlyContinuousCollection(median_header, annual_array.tolist())
+
+                annual_array = self.values_to_annual(
+                    sun_up_hours, _minimum_values, self.timestep)
+                minimum_header = header.duplicate()
+                minimum_header.metadata['Metric'] = 'Minimum'
+                _minimum_values = HourlyContinuousCollection(minimum_header, annual_array.tolist())
+
+                annual_array = self.values_to_annual(
+                    sun_up_hours, _maximum_values, self.timestep)
+                maximum_header = header.duplicate()
+                maximum_header.metadata['Metric'] = 'Maximum'
+                _maximum_values = HourlyContinuousCollection(maximum_header, annual_array.tolist())
+
+                annual_array = self.values_to_annual(
+                    sun_up_hours, _cumulative_values, self.timestep)
+                cumulative_header = header.duplicate()
+                cumulative_header.metadata['Metric'] = 'Cumulative'
+                _cumulative_values = HourlyContinuousCollection(
+                    cumulative_header, annual_array.tolist())
+
+            average_values.append(_average_values)
+            median_values.append(_median_values)
+            minimum_values.append(_minimum_values)
+            maximum_values.append(_maximum_values)
+            cumulative_values.append(_cumulative_values)
+
+        return (average_values, median_values, minimum_values, maximum_values,
+                cumulative_values, grids_info)
+
+    def annual_statistics_to_folder(
+            self, target_folder: str, hoys: list = None, states: DynamicSchedule = None,
+            grids_filter: str = '*', res_type: str = 'total', axis: int = 1):
+        """Compute summary statistics (average, median, minimum, maximum,
+        cumulative) for each sensor or timestep and write the values to a folder.
+
+        If hoys is left as None, the average will be computed for all study hours,
+        i.e., including sun down hours. This will likely lead to low average
+        and median values for a usual annual study.
+
+        Args:
+            target_folder: Folder path to write annual metrics in. Usually this
+                folder is called 'metrics'.
+            hoys: An optional list of numbers to select the hours of the year
+                (HOYs) for which results will be computed.
+            states: A dictionary of states. Defaults to None.
+            grids_filter: The name of a grid or a pattern to filter the grids.
+                Defaults to '*'.
+            res_type: Type of results to load. Defaults to 'total'.
+            axis: Axis along which statistics are computed:
+                - 1: compute per-sensor statistics over time (default)
+                - 0: compute per-timestep statistics across sensors; results are
+                     converted into HourlyContinuousCollection objects.
+        """
+        folder = Path(target_folder)
+        folder.mkdir(parents=True, exist_ok=True)
+
+        hoys = [] if hoys is None else hoys
+
+        (
+            average_values,
+            median_values,
+            minimum_values,
+            maximum_values,
+            cumulative_values,
+            grids_info
+        ) = self.annual_statistics(
+            hoys=hoys, states=states, grids_filter=grids_filter,
+            res_type=res_type, axis=axis
+        )
+
+        metrics = {
+            'average': average_values,
+            'median': median_values,
+            'minimum': minimum_values,
+            'maximum': maximum_values,
+            'cumulative': cumulative_values,
+        }
+
+        for metric_name in metrics:
+            metric_folder = folder.joinpath(f'{metric_name}_values')
+            metric_folder.mkdir(parents=True, exist_ok=True)
+            metric_folder.joinpath('grids_info.json').write_text(json.dumps(grids_info))
+
+        for idx, grid_info in enumerate(grids_info):
+            full_id = grid_info['full_id']
+            if axis == 1:
+                for metric_name, metric_values in metrics.items():
+                    data = metric_values[idx]
+                    metric_folder = folder.joinpath(f'{metric_name}_values')
+                    out_file = metric_folder.joinpath(f'{full_id}.{metric_name}')
+                    out_file.parent.mkdir(parents=True, exist_ok=True)
+                    np.savetxt(out_file, data, fmt="%.2f")
+            else:
+                for metric_name, metric_values in metrics.items():
+                    collection = metric_values[idx]
+                    data_dict = collection.to_dict()
+
+                    metric_folder = folder.joinpath(f'{metric_name}_values')
+                    out_file = metric_folder.joinpath(f'{full_id}_{metric_name}.json')
+                    out_file.parent.mkdir(parents=True, exist_ok=True)
+                    out_file.write_text(json.dumps(data_dict))
+
     def _array_to_annual_data(
             self, grid_info, states: DynamicSchedule = None,
             sensor_index: list = None, res_type: str = 'total'
@@ -937,7 +1127,8 @@ class Results(_ResultsFolder):
     def values_to_annual(
             hours: Union[List[float], np.ndarray],
             values: Union[List[float], np.ndarray],
-            timestep: int, base_value: int = 0,
+            timestep: int,
+            base_value: int = 0,
             dtype: np.dtype = np.float32) -> np.ndarray:
         """Map a 1D NumPy array based on a set of hours to an annual array.
 
@@ -962,7 +1153,8 @@ class Results(_ResultsFolder):
         if not isinstance(hours, np.ndarray):
             hours = np.array(hours)
         check_array_dim(values, 1)
-        assert hours.shape == values.shape
+        assert hours.shape == values.shape, \
+            (f'Shape of hours {hours.shape} must be the same as shape of values {values.shape}.')
 
         full_ap = np.array(AnalysisPeriod(timestep=timestep).hoys)
         indices = np.where(np.isin(full_ap, hours))[0]
@@ -972,6 +1164,37 @@ class Results(_ResultsFolder):
 
         return annual_array
 
+    @staticmethod
+    def pad_array_for_median(
+            array: np.ndarray, hoys: list, sun_down_hours: list, sensor_count: int
+        ) -> np.ndarray:
+        """Pad a filtered 2D result array with zeros so that median values correctly
+        account for sun-down hours.
+
+        - If no HOYs are given, pad with all sun-down hours.
+        - If HOYs are given, pad only with those HOYs that fall in sun-down hours.
+
+        Args:
+            array: 2D NumPy array of shape (sensor_count, N_filtered_hours).
+            hoys: List of selected hours-of-year (empty means all sun-up hours).
+            sun_down_hours: List of HOYs when the sun is down.
+            sensor_count: Number of sensors in the grid (array rows).
+
+        Returns:
+            A new 2D NumPy array padded with zero columns for sun-down hours.
+        """
+        if not hoys:
+            sdh_count = len(sun_down_hours)
+        else:
+            sdh_count = len(set(sun_down_hours).intersection(hoys))
+
+        if sdh_count == 0:
+            return array
+
+        zero_pad = np.zeros((sensor_count, sdh_count))
+
+        return np.concatenate((array, zero_pad), axis=1)
+
     def _index_from_datetime(self, datetime: DateTime) -> Union[int, None]:
         """Returns the index of the input datetime in the list of datetimes
         from the datetimes property.

{honeybee_radiance_postprocess-0.4.580.dist-info → honeybee_radiance_postprocess-0.4.582.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-radiance-postprocess
-Version: 0.4.580
+Version: 0.4.582
 Summary: Postprocessing of Radiance results and matrices
 Home-page: https://github.com/ladybug-tools/honeybee-radiance-postprocess
 Author: Ladybug Tools

{honeybee_radiance_postprocess-0.4.580.dist-info → honeybee_radiance_postprocess-0.4.582.dist-info}/RECORD

@@ -8,7 +8,7 @@ honeybee_radiance_postprocess/dynamic.py,sha256=RPJh2SsjASYJCsG5QRkazVCvzWjzMxm9
 honeybee_radiance_postprocess/electriclight.py,sha256=f1HTIoYI8s8pOGdS50QHy9OA6_RVw7IwLYrIEvZTdvU,821
 honeybee_radiance_postprocess/en17037.py,sha256=ejb84XyquVgmYK35d5TuM8msfA6LDF4OH-p__36GcCw,10888
 honeybee_radiance_postprocess/helper.py,sha256=NzGWfEmYlSzg4CpTuB9PMRSpKCIbN7gsDLVcmj3pr0c,9428
-honeybee_radiance_postprocess/metrics.py,sha256=Q7sMfSoVH366vMm3JWjF8rMnU-nc50QyG5n2MAq4kSk,14772
+honeybee_radiance_postprocess/metrics.py,sha256=XvRDcAu9-5UHzJvafvegbtwab8-oPchu_lw03UgjylE,15303
 honeybee_radiance_postprocess/reader.py,sha256=fEuqU-87vloLofwMxdCLKV4ZXoW1eMOXydsTgUwMCFk,2762
 honeybee_radiance_postprocess/type_hints.py,sha256=39kLNk9FxcQVGdL6bkP49jIFsf_1brP6r6w3khl9hqc,1212
 honeybee_radiance_postprocess/util.py,sha256=h7fipG9it_cfIk-kFP3X_IassVmfmphPiLxpydW43R4,6295
@@ -23,7 +23,7 @@ honeybee_radiance_postprocess/cli/grid.py,sha256=IMjfyw-XPaoSu550T_BuulRSawla8kY
 honeybee_radiance_postprocess/cli/leed.py,sha256=vup_tVcSnSO5R7U_WPVDAhtSSRrPzTUgV4j9lyxvxEk,5546
 honeybee_radiance_postprocess/cli/merge.py,sha256=NgQ5RM1-GrJQs_25IPzBvQ5PAn6oTKiB_N9SeHBxgCA,5840
 honeybee_radiance_postprocess/cli/mtxop.py,sha256=pbQsc4EnzsRStBX1-KcgIKmuTlVYiG1IyNjiqbwS2V0,5103
-honeybee_radiance_postprocess/cli/postprocess.py,sha256=Qvr5gEB9oQH4-4jww2ttxP1bWseBydxzRHymyrpcPWQ,39445
+honeybee_radiance_postprocess/cli/postprocess.py,sha256=6dSFievLH2wHNOyuTU7iNZXbmsX7ZeiHVct9S9NSY7M,41901
 honeybee_radiance_postprocess/cli/schedule.py,sha256=6uIy98Co4zm-ZRcELo4Lfx_aN3lNiqPe-BSimXwt1F8,3877
 honeybee_radiance_postprocess/cli/translate.py,sha256=W3G5aBN7pGx5sX3VoV1xZM6HL06Fw95iJb7vV-r6u7w,7396
 honeybee_radiance_postprocess/cli/two_phase.py,sha256=njkWBRxOqdRSp0JxLloWTGWmKruyONetgnIbjXhrrXw,8393
@@ -39,12 +39,12 @@ honeybee_radiance_postprocess/leed/leed_schedule.py,sha256=8NUISE6RbENK1IgMA5cC2
 honeybee_radiance_postprocess/results/__init__.py,sha256=1agBQbfT4Tf8KqSZzlfKYX8MeZryY4jJ1KB4HWqaDDk,182
 honeybee_radiance_postprocess/results/annual_daylight.py,sha256=ulv8kZvS6UkhCjaXSJKXQeVhUReRdx4M0tGvy7rA8CI,34586
 honeybee_radiance_postprocess/results/annual_irradiance.py,sha256=nA1VubesNDtRxgXpHSZxFMV67XxUntIHIu5H9qtDBSk,8483
-honeybee_radiance_postprocess/results/results.py,sha256=twfOF_ZNflxujWqpzigz4_pZ1vcSpF8cQxWIy7ajt0Y,56378
+honeybee_radiance_postprocess/results/results.py,sha256=CZZeyBTLVQt69qGdiePQsBIi1ppwIpqkp9lUpXv9orM,66846
 honeybee_radiance_postprocess/well/__init__.py,sha256=kQXElEqFnLGNnrMSpA51XDHoqBup849FHeAqWASIy6w,45
 honeybee_radiance_postprocess/well/well.py,sha256=FzxaLo3IdlvFZZ1UtblBk9zsKl_EfsCKIcAgfucq-nE,24762
-honeybee_radiance_postprocess-0.4.580.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-honeybee_radiance_postprocess-0.4.580.dist-info/METADATA,sha256=unPxI_Y_sVFgWhH8RFBcWCzGadn42p4jYwyd_Z_PHW4,2575
-honeybee_radiance_postprocess-0.4.580.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-honeybee_radiance_postprocess-0.4.580.dist-info/entry_points.txt,sha256=gFtVPx6UItXt27GfEZZO00eOZChJJEL6JwGSAB_O3rs,96
-honeybee_radiance_postprocess-0.4.580.dist-info/top_level.txt,sha256=4-sFbzy7ewP2EDqJV3jeFlAFx7SuxtoBBELWaKAnLdA,30
-honeybee_radiance_postprocess-0.4.580.dist-info/RECORD,,
+honeybee_radiance_postprocess-0.4.582.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+honeybee_radiance_postprocess-0.4.582.dist-info/METADATA,sha256=kYSR8bEwNqoAf254iDcHsM9Qh_rpP4IJ88HCExmGo3o,2575
+honeybee_radiance_postprocess-0.4.582.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+honeybee_radiance_postprocess-0.4.582.dist-info/entry_points.txt,sha256=gFtVPx6UItXt27GfEZZO00eOZChJJEL6JwGSAB_O3rs,96
+honeybee_radiance_postprocess-0.4.582.dist-info/top_level.txt,sha256=4-sFbzy7ewP2EDqJV3jeFlAFx7SuxtoBBELWaKAnLdA,30
+honeybee_radiance_postprocess-0.4.582.dist-info/RECORD,,