HBV-Lab 0.1.0__py3-none-any.whl

HBV_Lab/uncertainty.py

@@ -0,0 +1,364 @@
+class uncertainty:
+    
+    def evaluate_uncertainty(self, n_runs=10000, objective='NSE', save_best=10, 
+                        plot_results=True, verbose=True, seed=None, narrow_percent=None,
+                        exclude_warmup_in_plots=True):
+        """
+        Perform uncertainty analysis on an HBV model by sampling from parameter ranges.
+        
+        Parameters:
+        -----------
+        self : HBVmodel
+            The HBV model instance to analyze (typically after calibration)
+        n_runs : int, default 10000
+            Number of model runs with different parameter sets
+        objective : str, default 'NSE'
+            Objective function to evaluate model performance. Options are:
+            - 'NSE': Nash-Sutcliffe Efficiency (higher is better)
+            - 'KGE': Kling-Gupta Efficiency (higher is better)
+            - 'RMSE': Root Mean Square Error (lower is better)
+            - 'MAE': Mean Absolute Error (lower is better)
+        save_best : int, default 10
+            Number of best parameter sets to save
+        plot_results : bool, default True
+            Whether to plot the results after analysis
+        verbose : bool, default True
+            Whether to print progress information
+        seed : int, optional
+            Random seed for reproducibility
+        narrow_percent : float, optional
+            If provided, narrows the parameter search space to this percentage around the default values
+        exclude_warmup_in_plots : bool, default True
+            Whether to exclude the warmup period from plots
+            
+        Returns:
+        --------
+        dict
+            Dictionary containing the best parameter sets, their performance metrics,
+            and uncertainty statistics
+        """
+        import numpy as np
+        import pandas as pd
+        import matplotlib.pyplot as plt
+        import time
+        import copy
+        from tqdm.auto import tqdm
+        
+        if self.data is None:
+            raise ValueError("No data loaded. Use load_data() method first.")
+            
+        # Check if observed discharge data is available
+        if (self.column_names['obs_q'] is None or 
+            self.column_names['obs_q'] not in self.data.columns):
+            raise ValueError("Observed discharge data is required for uncertainty analysis.")
+        
+        # Set random seed for reproducibility if provided
+        if seed is not None:
+            np.random.seed(seed)
+        
+        # Store the initial states and parameters to restore later
+        initial_states = copy.deepcopy(self.states)
+        original_params = copy.deepcopy(self.params)
+        
+        # Extract observed discharge data
+        obs_q = self.data[self.column_names['obs_q']].values
+        
+        # Get valid indices (where obs_q is not NaN)
+        valid_idx = ~np.isnan(obs_q)
+        if np.sum(valid_idx) == 0:
+            raise ValueError("No valid observed discharge values found.")
+        
+        # Create flat parameter list for sampling
+        param_info = []
+        for group_name, group in self.params.items():
+            for param_name, param_data in group.items():
+                param_info.append({
+                    'group': group_name,
+                    'name': param_name,
+                    'min': param_data['min'],
+                    'max': param_data['max'],
+                    'default': param_data['default']
+                })
+        # Narrow ranges around the defaults (best fit) if narrow_percent is specified
+        if narrow_percent is not None:
+            for p in param_info:
+                best_val = p['default']
+                full_range = p['max'] - p['min']
+                delta = full_range * narrow_percent
+
+                new_min = max(p['min'], best_val - delta)
+                new_max = min(p['max'], best_val + delta)
+
+                p['min'] = new_min
+                p['max'] = new_max
+                if verbose:
+                    print(f"Narrowed range {p['group']}_{p['name']}: {new_min:.4f} to {new_max:.4f}")        
+        
+        # Helper function to create parameter dictionary from sampled values
+        def create_param_dict(flat_params):
+            param_dict = {group_name: {} for group_name in set(p['group'] for p in param_info)}
+            
+            for i, p in enumerate(param_info):
+                if p['name'] not in param_dict[p['group']]:
+                    param_dict[p['group']][p['name']] = {}
+                
+                param_dict[p['group']][p['name']]['min'] = p['min']
+                param_dict[p['group']][p['name']]['max'] = p['max']
+                param_dict[p['group']][p['name']]['default'] = flat_params[i]
+            
+            return param_dict
+        
+        # Evaluate model with a given parameter set
+        def evaluate_model(params):
+            # Create parameter dictionary
+            param_dict = create_param_dict(params)
+            
+            # Update model parameters
+            self.params = param_dict
+            
+            # Reset states
+            self.states = copy.deepcopy(initial_states)
+            
+            # Run the model
+            self.run(verbose=False)  # Setting verbose=False to reduce output clutter
+            
+            # Calculate performance metrics
+            self.calculate_performance_metrics(verbose=False)  # Setting verbose=False to reduce output clutter
+            
+            # Return the specified objective
+            if objective == 'NSE':
+                return self.performance_metrics['NSE']
+            elif objective == 'KGE':
+                return self.performance_metrics['KGE']
+            elif objective == 'RMSE':
+                return -self.performance_metrics['RMSE']  # Negative for minimization
+            elif objective == 'MAE':
+                return -self.performance_metrics['MAE']  # Negative for minimization
+            else:
+                raise ValueError(f"Unknown objective function: {objective}")
+        
+        # Prepare to store results
+        n_params = len(param_info)
+        results = {
+            'parameters': np.zeros((n_runs, n_params)),
+            'performance': np.zeros(n_runs)
+        }
+        
+        # Start timing
+        start_time = time.time()
+        
+        if verbose:
+            print(f"Starting uncertainty analysis with {n_runs} runs...")
+            print(f"Sampling {n_params} parameters uniformly across their ranges")
+            print(f"Evaluating with {objective} as the objective function")
+        
+        # Run Monte Carlo simulations
+        for i in tqdm(range(n_runs)):
+            # Sample parameters uniformly from their ranges
+            sampled_params = np.array([np.random.uniform(p['min'], p['max']) for p in param_info])
+            
+            # Store parameters
+            results['parameters'][i, :] = sampled_params
+            
+            # Evaluate model and store performance
+            results['performance'][i] = evaluate_model(sampled_params)
+        
+        # Sort results by performance (descending order)
+        sort_indices = np.argsort(-results['performance'])
+        sorted_performance = results['performance'][sort_indices]
+        sorted_parameters = results['parameters'][sort_indices]
+        
+        # Get the best parameter sets
+        best_indices = sort_indices[:save_best]
+        best_performance = results['performance'][best_indices]
+        best_parameters = results['parameters'][best_indices]
+        
+        # Save best parameter sets
+        best_param_sets = []
+        for i in range(save_best):
+            param_set = create_param_dict(best_parameters[i])
+            best_param_sets.append({
+                'parameters': param_set,
+                'performance': best_performance[i] if objective in ['NSE', 'KGE'] else -best_performance[i]
+            })
+        
+        # Store performance with original (calibrated) parameters
+        self.params = original_params
+        self.states = copy.deepcopy(initial_states)
+        self.run(verbose=False)
+        self.calculate_performance_metrics(verbose=False)
+        original_performance = self.performance_metrics[objective]
+        if objective in ['RMSE', 'MAE']:
+            original_performance = -original_performance  # Adjust sign for consistent comparison
+        
+        # Compare best run with original (calibrated) run
+        best_vs_original = best_performance[0] - original_performance
+        
+        # Generate prediction intervals
+        time_index = self.data.index
+        dates = self.results['dates']  # Get dates from model results
+        obs_q_valid = obs_q[valid_idx]
+        
+        # Create a dataframe to store all the best model runs
+        best_runs_df = pd.DataFrame(index=time_index)
+        best_runs_df['dates'] = dates  # Add dates column
+        best_runs_df['observed'] = self.data[self.column_names['obs_q']]
+        
+        # Run model with best parameter sets and store results
+        for i in range(save_best):
+            self.params = create_param_dict(best_parameters[i])
+            self.states = copy.deepcopy(initial_states)
+            self.run(verbose=False)
+            best_runs_df[f'best_{i+1}'] = self.results['discharge']
+        
+        # Run model with original parameters to get baseline
+        self.params = original_params
+        self.states = copy.deepcopy(initial_states)
+        self.run(verbose=False)
+        best_runs_df['original'] = self.results['discharge']
+        
+        # Calculate 95% prediction interval from best runs
+        best_runs_df['q5'] = best_runs_df.filter(like='best_').quantile(0.025, axis=1)
+        best_runs_df['q95'] = best_runs_df.filter(like='best_').quantile(0.975, axis=1)
+        
+        # Determine warmup period index for plotting
+        warmup_idx = 0
+        if exclude_warmup_in_plots and hasattr(self, 'warmup_end') and self.warmup_end is not None:
+            if 'dates' in best_runs_df.columns:
+                # Find the index of the first date after warmup_end
+                warmup_idx = np.sum(best_runs_df['dates'] <= self.warmup_end)
+                if verbose:
+                    print(f"Excluding data up to {self.warmup_end} ({warmup_idx} timesteps) from plots as warmup period.")
+            else:
+                # Default to 10% if no dates available
+                warmup_idx = int(len(obs_q) * 0.1)
+                if verbose:
+                    print(f"No dates found. Defaulting to exclude first {warmup_idx} timesteps (10% of data) from plots.")
+        elif exclude_warmup_in_plots:
+            # Default: exclude first 10% of the data
+            warmup_idx = int(len(obs_q) * 0.1)
+            if verbose:
+                print(f"No warmup_end specified. Excluding first {warmup_idx} timesteps (10% of data) from plots.")
+        
+        # Plot results if requested
+        if plot_results:
+            plt.figure(figsize=(12, 6))
+            
+            # Apply warmup exclusion for plotting
+            plot_df = best_runs_df.iloc[warmup_idx:].copy()
+            plot_dates = dates[warmup_idx:] if isinstance(dates, np.ndarray) else plot_df.index
+            
+            # Plot uncertainty band
+            plt.fill_between(plot_dates, plot_df['q5'], plot_df['q95'], 
+                            color='lightgray', alpha=0.7, label='95% Prediction Interval')
+            
+            # Plot best run
+            plt.plot(plot_dates, plot_df['best_1'], 'b-', linewidth=1, label='Best Run')
+            
+            # Plot original (calibrated) run
+            plt.plot(plot_dates, plot_df['original'], 'r--', linewidth=1.5, label='Calibrated Run')
+            
+            # Plot observed data
+            valid_obs = ~np.isnan(plot_df['observed'])
+            plt.plot(plot_dates[valid_obs], plot_df['observed'][valid_obs], 'k.', 
+                     markersize=3, label='Observed')
+            
+            plt.title(f'Uncertainty Analysis Results (n={n_runs})')
+            plt.xlabel('Time')
+            plt.ylabel('Discharge (mm/day)')
+            
+            # Set sensible y-axis limits
+            valid_data = np.concatenate([
+                plot_df['observed'][valid_obs],
+                plot_df['original'],
+                plot_df['best_1'],
+                plot_df['q95']
+            ])
+            max_val = np.nanmax(valid_data)
+            leeway = 0.1 * max_val  # 10% extra space
+            plt.ylim(0, max_val + leeway)
+            
+            plt.legend()
+            plt.grid(True, alpha=0.3)
+            
+            # Add annotation about performance
+            if objective in ['NSE', 'KGE']:
+                better_text = "better" if best_vs_original > 0 else "worse"
+                diff_text = f"Best run is {abs(best_vs_original):.4f} {better_text} than calibrated run"
+            else:
+                better_text = "better" if best_vs_original < 0 else "worse"
+                diff_text = f"Best run is {abs(best_vs_original):.4f} {better_text} than calibrated run"
+            
+            plt.figtext(0.5, 0.002, diff_text, ha='center', fontsize=12)
+            
+            plt.tight_layout()
+            plt.show()
+            
+            # Plot parameter distributions for the top runs
+            n_params = len(param_info)
+            n_cols = min(3, n_params)
+            n_rows = (n_params + n_cols - 1) // n_cols
+            
+            plt.figure(figsize=(15, n_rows * 3))
+            
+            for i, p in enumerate(param_info):
+                plt.subplot(n_rows, n_cols, i + 1)
+                param_values = best_parameters[:save_best, i]
+                
+                plt.hist(param_values, bins=min(10, save_best), alpha=0.7)
+                plt.axvline(p['default'], color='r', linestyle='--', 
+                            linewidth=2, label='Calibrated')
+                plt.axvline(best_parameters[0, i], color='b', linestyle='-',
+                            linewidth=2, label='Best Run')
+                
+                plt.title(f"{p['group']}_{p['name']}")
+                plt.xlabel('Parameter Value')
+                plt.ylabel('Frequency')
+                
+                # Only show legend on the first subplot
+                if i == 0:
+                    plt.legend()
+                    
+            plt.tight_layout()
+            plt.show()
+        
+        # Compute elapsed time
+        elapsed_time = time.time() - start_time
+        
+        if verbose:
+            print(f"\nUncertainty analysis completed in {elapsed_time:.2f} seconds")
+            print(f"Analyzed {n_runs} parameter sets")
+            
+            print("\nTop Performance Values:")
+            for i in range(min(5, save_best)):
+                perf_value = best_performance[i] if objective in ['NSE', 'KGE'] else -best_performance[i]
+                print(f"  Run {i+1}: {objective} = {perf_value:.4f}")
+            
+            print(f"\nOriginal (Calibrated) Performance: {objective} = {original_performance:.4f}")
+            
+            if objective in ['NSE', 'KGE']:
+                better_text = "better" if best_vs_original > 0 else "worse"
+            else:
+                better_text = "better" if best_vs_original < 0 else "worse"
+                
+            print(f"Best run is {abs(best_vs_original):.4f} {better_text} than calibrated run")
+        
+        # Restore original parameters and states
+        self.params = original_params
+        self.states = copy.deepcopy(initial_states)
+        
+        # Return results
+        return {
+            'best_parameter_sets': best_param_sets,
+            'uncertainty_bounds': {
+                'lower': best_runs_df['q5'].tolist(),
+                'upper': best_runs_df['q95'].tolist()
+            },
+            'best_runs': best_runs_df,
+            'objective': objective,
+            'n_runs': n_runs,
+            'save_best': save_best,
+            'original_performance': original_performance,
+            'best_performance': best_performance[0] if objective in ['NSE', 'KGE'] else -best_performance[0],
+            #'warmup_idx': warmup_idx
+        }

hbv_lab-0.1.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: HBV_Lab
+Version: 0.1.0
+Summary: An intuitive, object-oriented and user-friendly Python implementation of a lumped conceptual HBV hydrological model for educational and research purposes.
+Home-page: https://github.com/abdallaox/HBV_python_implementation
+Author: Abdalla Mohammed
+Author-email: abdalla.mohammed.ox@gmail.com
+License: MIT
+Keywords: hydrology HBV-model rainfall-runoff hydrological-modelling
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# HBV_Lab (Python implementation of a lumped conceptual HBV model)
+
+HBV is a simple conceptual hydrological model that simulates the main hydrological processes related to snow, soil, groundwater, and routing [[1]](https://watermark.silverchair.com/147.pdf?token=AQECAHi208BE49Ooan9kkhW_Ercy7Dm3ZL_9Cf3qfKAc485ysgAAA_swggP3BgkqhkiG9w0BBwagggPoMIID5AIBADCCA90GCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQMKaeJWQ7VWIq_mqLkAgEQgIIDrh5vsWeaZ0wY6F-ERiovjNb4KimkGt_o5Pj5ZbNlsoszUqDq-oFtdcns5O02KBex_JakkQDDkMBBlg_PFsx9vpuBqYn1kC7EnMp274TfQ2NxQC70hO3OXoYWvMcZRf-Zl3r9w2LYzlmGc9fk2PmF173MeCsuIKaaA79mD0QvqI_9hN8Dz6P43uY3ybzhZPAWUaOFtudQTFy6iC9DZ1jChvSOBK_LpqltPDB5kbyDXkB8OYQl1RQQ3bBtO_G3pwFuat3m2YyKINkI7kLl6alxTs0VQc9cEXgxs_QkBubg_VBtVIaD8mNa7BxQ3PrWpPyrn02TfcAq67SVekWeN9K94P4B8aBBYuyi1-W8vqlp22gzHzr6FrtiP7PEE-7ymBAWQgro7XwZ4bulncCHb1seCeoLbuStdR93KGvKto6hOyN3uxuQZ5e1iP7726MkrMI5MhmCuw8awj2qQeH4LL4g1UuublCNtCX0KNkTCtdj3OUJfxORlLqcCS6PMwM7xkZpw4ytgJ1ro77v3T-yn3V7TbgriNX7UB9BWU2HGVz6SsSkZQoEcop0GPb_EpoqMMkw3NwEn8alJBXTcSbjkrAzWPm6kgZ3agvzbAI53fvueVayzDiZ49ifMnImnn3ge6Dcp3tb-M1Yw6rj8et1UhgfhJMbE0VGc_05KvEdrQYTndorlZPPUPpRK-3-jHOTDwOjz2ME-orp_oAcwoRqaja-e1aeLAuNFImu7PKsRSyn1x3zTh_2lks1_xt6T8kQgXeRluGhJwth1hXCa2ld7qrd1wo6H-6x63UFwO35ygr5MuIOuUnf0W2Rfb7tQtiPY9Vn_snj3frwtqBPOsgQUYtS5jXkSL-FngaOnUedrBvtv0iybblBtdd-LnClDE3KRDdVSjAAa0VS3v5RoUBxs3c8p44N5D3S4NQvdc8PZy9aHeJ6Tl7VNg-gWneGm3_BrOgiW1ylifGMb3X0J6NoYHSDy0mzR51VcM3w-gSCg44ejKuMPqS1yI-yTkZrAfXEKI8ECNdjLz_A9OjaMHr_saFijNhrdHX_l9_bFlfQEzh1zq6ueHZR6Bx3bMriUQYyajTQ0zpNdaQQXm1m5Caq4A-Agkmd6m9SPQNRquMCSYkP10uEw1deYjz6nAhELvTJhG7T8e2ZZ_uYantsrPO54_MkPTPI--4Mx9ePzP9modf7Dc3c98Iu1230duLUQd5sfkkRCF1Ab7P-FlJpUYt1xA2bS7csXfYc_IToq4EcNXx_Zw). There are many software packages and off-the-shelf products that implement different versions of it [[2]](https://www.geo.uzh.ch/en/units/h2k/Services/HBV-Model.html) [[3]](https://hess.copernicus.org/articles/17/445/2013/).
+
+I've been experimenting with the model lately and—in an endeavour to better understand the logic behind it—I decided to implement my own version—in Python, following an intuitive object-oriented programming approach.
+
+This versioin implements the snow, soil, response and routing routines—controled by 14 calibratable parameters as shown below. In addition to calibration and uncertainty analysis modules.
+```python
+parameters   = {
+                  'snow':        ['TT', 'CFMAX', 'SFCF', 'CFR', 'CWH'],
+                  'soil':        ['FC', 'LP', 'BETA'],
+                  'response':    ['K0', 'K1', 'K2', 'UZL', 'PERC']
+                  'routing' :    [ 'MAXBAS'],
+               }
+```
+
+
+This can be flexibly used for different modelling tasks, but can also be used in a classroom setup—to explain hydrological concepts (processes, calibration, uncertainty analysis, etc.).
+
+## Get Started
+
+### Install the Package
+```bash
+pip install HBV_Lab
+```
+### How to Use
+It is very intuitive—you create a model like an object which has attributes (data, parameters, initial conditions, etc.) that you can assign and access. The object also performs functions (calibration, uncertainty estimation, save, load, etc.)
+```python
+from HBV_Lab import HBVModel
+model = HBVModel()
+model.load_data("pandas dataframe")
+model.set_parameters(params)
+model.run()
+model.calibrate()
+model.evaluate_uncertainity()
+model.plot_results()
+model.save_results()
+model.save_model("path")
+model.load_model("path")
+```
+### Tutorial
+Start by following a simple case study in the notebook:  [**quick_start_guide.ipynb**](quick_start_guide.ipynb)
+### Play with HBV 
+Get a feeling of how HBV model work and the role of the different parameters in [**HBVLAB**](https://www.linkedin.com/in/abdallaimam/) (which uses a model developed with this HBV implementation).
+### References 
+**[1]**    Bergström, S., & Forsman, A. (1973). DEVELOPMENT OF A CONCEPTUAL DETERMINISTIC RAINFALL-RUNOFF MODEL. Hydrology Research, 4, 147-170.
+
+**[2]**    Seibert, J. and Vis, M. J. P.: Teaching hydrological modeling with a user-friendly catchment-runoff-model software package, Hydrol. Earth Syst. Sci., 16, 3315–3325, https://doi.org/10.5194/hess-16-3315-2012, 2012.
+
+**[3]**     AghaKouchak, A., Nakhjiri, N., and Habib, E.: An educational model for ensemble streamflow simulation and uncertainty analysis, Hydrol. Earth Syst. Sci., 17, 445–452, https://doi.org/10.5194/hess-17-445-2013, 2013.
+

hbv_lab-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+HBV_Lab/HBV_model.py,sha256=qESzu_BtSeHioXjlWTvRZ75Z3JmcsZFv1251E6rtZ7w,34459
+HBV_Lab/__init__.py,sha256=IVVuP29S05wRm2S6DPfv6T_HZLLdOBSHH1d5wvXUn3U,31
+HBV_Lab/calibration.py,sha256=h7aXvYkrFB8x9XZF2Oq_yCKbJ4NrlKWUS87gzRboUOc,10596
+HBV_Lab/hbv_step.py,sha256=bVuruQP-_-wPnBJPRmJAWTkgtxXG2yQWej37dyg9khY,2957
+HBV_Lab/response.py,sha256=bmV_9M7JlX7DJgbLynb620t4_t-1f1OAF6ovcKmunDg,3123
+HBV_Lab/routing.py,sha256=XG08CivFlGBNbpHY4jeyKRDDxuVIM826QPlloeWUxJU,1241
+HBV_Lab/snow.py,sha256=3WLC0w7CugDElnu5OHtFveDV3qQNqKkuy96T37CA9wU,2532
+HBV_Lab/soil.py,sha256=HwbAjusb0PstpkFKauCNWx5d8ad5qbcXurIuygVIPYY,2802
+HBV_Lab/uncertainty.py,sha256=gqF8njeICYzOfG-03_DADBdeGz-RD-IL6Mn41n2ou2E,16436
+hbv_lab-0.1.0.dist-info/licenses/LICENSE,sha256=Bfu0Cd9crnTcYQvU2HptthyOzhc7jBTUicQdMhKsDoU,1094
+hbv_lab-0.1.0.dist-info/METADATA,sha256=22w42e2UVuNp10DSr5JFOwV8UfeuOgHew06AUD65pk0,5593
+hbv_lab-0.1.0.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+hbv_lab-0.1.0.dist-info/top_level.txt,sha256=8PP6duueMX7y7CQk0_x7COQYhAfVDZBiMRp9j_sREkc,8
+hbv_lab-0.1.0.dist-info/RECORD,,

hbv_lab-0.1.0.dist-info/WHEEL

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

hbv_lab-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ABDALLA MOHAMMED
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hbv_lab-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+HBV_Lab