huff 1.5.1__py3-none-any.whl → 1.5.3__py3-none-any.whl

huff/models.py

@@ -4,8 +4,8 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.5.1
-# Last update: 2025-07-01 17:10
+# Version:     1.5.3
+# Last update: 2025-07-15 17:22
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -105,7 +105,7 @@ class CustomerOrigins:
         metadata = self.metadata
 
         if marketsize_col not in geodata_gpd_original.columns:
-            raise KeyError ("Column " + marketsize_col + " not in data")
+            raise KeyError ("Error while defining market size variable: Column " + marketsize_col + " not in data")
         else:
             metadata["marketsize_col"] = marketsize_col
 
@@ -140,13 +140,13 @@ class CustomerOrigins:
         metadata = self.metadata
 
         if func not in ["power", "exponential", "logistic"]:
-            raise ValueError("Parameter 'func' must be 'power', 'exponential' or 'logistic'")
+            raise ValueError("Error while defining transport costs weighting: Parameter 'func' must be 'power', 'exponential' or 'logistic'")
 
         if isinstance(param_lambda, list) and func != "logistic":
-            raise ValueError("Function type "+ func + " requires one single parameter value")
+            raise ValueError("Error while defining transport costs weighting: Function type "+ func + " requires one single parameter value")
         
         if isinstance(param_lambda, (int, float)) and func == "logistic":
-            raise ValueError("Function type "+ func + " requires two parameters in a list")
+            raise ValueError("Error while defining transport costs weighting: Function type "+ func + " requires two parameters in a list")
         
         metadata["weighting"][0]["name"] = "t_ij"
         metadata["weighting"][0]["func"] = func
@@ -299,7 +299,7 @@ class SupplyLocations:
         metadata = self.metadata
 
         if attraction_col not in geodata_gpd_original.columns:
-            raise KeyError ("Column " + attraction_col + " not in data")
+            raise KeyError ("Error while defining attraction variable: Column " + attraction_col + " not in data")
         else:
             metadata["attraction_col"][0] = attraction_col
 
@@ -316,7 +316,7 @@ class SupplyLocations:
         metadata = self.metadata
 
         if metadata["attraction_col"] is None:
-            raise ValueError ("Attraction column is not yet defined. Use SupplyLocations.define_attraction()")
+            raise ValueError ("Error while defining attraction weighting: Attraction column is not yet defined. Use SupplyLocations.define_attraction()")
         
         metadata["weighting"][0]["name"] = "A_j"
         metadata["weighting"][0]["func"] = func
@@ -336,7 +336,7 @@ class SupplyLocations:
         metadata = self.metadata
 
         if metadata["attraction_col"] is None:
-            raise ValueError ("Attraction column is not yet defined. Use SupplyLocations.define_attraction()")
+            raise ValueError ("Error while adding utility variable: Attraction column is not yet defined. Use SupplyLocations.define_attraction()")
 
         no_attraction_vars = len(metadata["attraction_col"])
         new_key = no_attraction_vars
@@ -371,9 +371,9 @@ class SupplyLocations:
         new_destinations_metadata = new_destinations.get_metadata()
 
         if list(new_destinations_gpd_original.columns) != list(geodata_gpd_original.columns):
-            raise KeyError("Supply locations and new destinations data have different column names.")
+            raise KeyError("Error while adding new destinations: Supply locations and new destinations data have different column names.")
         if list(new_destinations_gpd.columns) != list(geodata_gpd.columns):
-            raise KeyError("Supply locations and new destinations data have different column names.")
+            raise KeyError("Error while adding new destinations: Supply locations and new destinations data have different column names.")
 
         geodata_gpd_original = pd.concat(
             [
@@ -644,7 +644,7 @@ class InteractionMatrix:
                 )
             
             if time_distance_matrix.get_metadata() is None:
-                raise ValueError ("No transport costs matrix was built.")
+                raise ValueError ("Error in transport costs calculation: No transport costs matrix was built.")
 
             transport_costs_matrix = time_distance_matrix.get_matrix()
             transport_costs_matrix_config = time_distance_matrix.get_config()
@@ -773,13 +773,13 @@ class InteractionMatrix:
         interaction_matrix_metadata = self.get_metadata()
 
         if "t_ij" not in interaction_matrix_df.columns:
-            raise ValueError ("No transport cost variable in interaction matrix")
+            raise ValueError ("Error in utility calculation: No transport cost variable in interaction matrix")
         if "A_j" not in interaction_matrix_df.columns:
-            raise ValueError ("No attraction variable in interaction matrix")
+            raise ValueError ("Error in utility calculation: No attraction variable in interaction matrix")
         if interaction_matrix_df["t_ij"].isna().all():
-            raise ValueError ("Transport cost variable is not defined")
+            raise ValueError ("Error in utility calculation: Transport cost variable is not defined")
         if interaction_matrix_df["A_j"].isna().all():
-            raise ValueError ("Attraction variable is not defined")
+            raise ValueError ("Error in utility calculation: Attraction variable is not defined")
 
         check_vars(
             df = interaction_matrix_df,
@@ -797,7 +797,7 @@ class InteractionMatrix:
         elif tc_weighting["func"] == "logistic":
             interaction_matrix_df["t_ij_weighted"] = 1+np.exp(tc_weighting["param"][0] + tc_weighting["param"][1] * interaction_matrix_df['t_ij'])
         else:
-            raise ValueError ("Transport costs weighting is not defined.")
+            raise ValueError ("Error in utility calculation: Transport costs weighting is not defined.")
                            
         supply_locations = self.supply_locations
         supply_locations_metadata = supply_locations.get_metadata()
@@ -808,7 +808,7 @@ class InteractionMatrix:
         elif tc_weighting["func"] == "exponential":
             interaction_matrix_df["A_j_weighted"] = np.exp(attraction_weighting["param"] * interaction_matrix_df["A_j"])
         else:
-            raise ValueError ("Attraction weighting is not defined.")
+            raise ValueError ("Error in utility calculation: Attraction weighting is not defined.")
         
         attrac_vars = supply_locations_metadata["attraction_col"]
         attrac_vars_no = len(attrac_vars)
@@ -831,7 +831,7 @@ class InteractionMatrix:
                 elif func == "exponential":
                     interaction_matrix_df[name+"_weighted"] = np.exp(param * interaction_matrix_df[name])
                 else:
-                    raise ValueError ("Weighting for " + name + " is not defined.")
+                    raise ValueError ("Error in utility calculation: Weighting for " + name + " is not defined.")
                 
                 interaction_matrix_df["A_j_weighted"] = interaction_matrix_df["A_j_weighted"]*interaction_matrix_df[name+"_weighted"]
 
@@ -881,9 +881,9 @@ class InteractionMatrix:
         interaction_matrix_df = self.interaction_matrix_df
 
         if "C_i" not in interaction_matrix_df.columns:
-            raise ValueError ("No market size variable in interaction matrix")
+            raise ValueError ("Error in flows calculation: No market size variable in interaction matrix")
         if interaction_matrix_df["C_i"].isna().all():
-            raise ValueError ("Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
+            raise ValueError ("Error in flows calculation: Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
 
         check_vars(
             df = interaction_matrix_df,
@@ -940,7 +940,7 @@ class InteractionMatrix:
         else:
             
             if "C_i" not in interaction_matrix_df.columns or interaction_matrix_df["C_i"].isna().all():
-                raise ValueError("Customer origins market size is not available")            
+                raise ValueError("Error in hansen accessibility calculation: Customer origins market size is not available")            
             
             customer_origins_metadata = self.customer_origins.get_metadata()
             tc_weighting = customer_origins_metadata["weighting"][0]
@@ -951,7 +951,7 @@ class InteractionMatrix:
             elif tc_weighting["func"] == "logistic":
                 interaction_matrix_df["t_ij_weighted"] = 1+np.exp(tc_weighting["param"][0] + tc_weighting["param"][1] * interaction_matrix_df['t_ij'])
             else:
-                raise ValueError ("Transport costs weighting is not defined.")
+                raise ValueError ("Error in hansen accessibility calculation: Transport costs weighting is not defined.")
                         
             interaction_matrix_df["U_ji"] = interaction_matrix_df["C_i"]*interaction_matrix_df["t_ij_weighted"]           
             hansen_df = pd.DataFrame(interaction_matrix_df.groupby("j")["U_ji"].sum()).reset_index()
@@ -1077,16 +1077,16 @@ class InteractionMatrix:
         ):
         
         if fit_by not in ["probabilities", "flows"]:
-            raise ValueError ("Parameter 'fit_by' must be 'probabilities' or 'flows'")
+            raise ValueError ("Error in loglik: Parameter 'fit_by' must be 'probabilities' or 'flows'")
 
         if not isinstance(params, list):
             if isinstance(params, np.ndarray):
                 params = params.tolist()
             else:
-                raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+                raise ValueError("Error in loglik: Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
         
         if len(params) < 2:
-            raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+            raise ValueError("Error in loglik: Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
         
         customer_origins = self.customer_origins
         customer_origins_metadata = customer_origins.get_metadata()
@@ -1096,7 +1096,7 @@ class InteractionMatrix:
         if customer_origins_metadata["weighting"][0]["func"] == "logistic":
             
             if len(params) < 3:
-                raise ValueError("When using logistic weighting, parameter 'params' must be a list or np.ndarray with at least 3 parameter values")
+                raise ValueError("Error in loglik: When using logistic weighting, parameter 'params' must be a list or np.ndarray with at least 3 parameter values")
         
             param_gamma, param_lambda, param_lambda2 = params[0], params[1], params[2]
 
@@ -1116,7 +1116,7 @@ class InteractionMatrix:
             
             else:
                 
-                raise ValueError ("Huff Model with transport cost weighting of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 2 input parameters")
+                raise ValueError ("Error in loglik: Huff Model with transport cost weighting of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 2 input parameters")
         
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
             
@@ -1126,7 +1126,7 @@ class InteractionMatrix:
             
             else:
 
-                raise ValueError("Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 3 input parameters")
+                raise ValueError("Error in loglik: Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 3 input parameters")
 
         if (customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"] and len(params) > 2): 
             
@@ -1224,10 +1224,10 @@ class InteractionMatrix:
         params_metadata = params_metadata_customer_origins+params_metadata_supply_locations
 
         if len(initial_params) < 2 or len(initial_params) != params_metadata:
-            raise ValueError("Parameter 'initial_params' must be a list with " + str(params_metadata) + " entries (Attaction: " + str(params_metadata_supply_locations) + ", Transport costs: " + str(params_metadata_customer_origins) + ")")
+            raise ValueError("Error in huff_ml_fit: Parameter 'initial_params' must be a list with " + str(params_metadata) + " entries (Attaction: " + str(params_metadata_supply_locations) + ", Transport costs: " + str(params_metadata_customer_origins) + ")")
         
         if len(bounds) != len(initial_params):            
-            raise ValueError("Parameter 'bounds' must have the same length as parameter 'initial_params' (" + str(len(bounds)) + ", " + str(len(initial_params)) + ")")
+            raise ValueError("Error in huff_ml_fit: Parameter 'bounds' must have the same length as parameter 'initial_params' (" + str(len(bounds)) + ", " + str(len(initial_params)) + ")")
 
         ml_result = minimize(
             self.loglik,
@@ -1292,21 +1292,6 @@ class InteractionMatrix:
             print(f"Optimization via {method} algorithm succeeded with parameters: {', '.join(str(round(par, 3)) for par in param_results)}.")
    
         else:
-
-            # param_gamma = None
-            # param_lambda = None
-            
-            # supply_locations_metadata["weighting"][0]["param"] = param_gamma            
-            
-            # if customer_origins_metadata["weighting"][0]["func"] == "logistic":
-                               
-            #     param_lambda2 = None                
-            #     customer_origins_metadata["weighting"][0]["param"][0] = param_lambda
-            #     customer_origins_metadata["weighting"][0]["param"][1] = param_lambda2
-            
-            # else:
-                
-            #     customer_origins_metadata["weighting"][0]["param"] = param_lambda
                 
             print(f"Optimiziation via {method} algorithm failed with error message: '{ml_result.message}'. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html for all available algorithms.")
 
@@ -1316,20 +1301,28 @@ class InteractionMatrix:
         if update_estimates:
 
             if "p_ij_emp" not in self.interaction_matrix_df.columns:
+                
                 self.interaction_matrix_df["p_ij_emp"] = self.interaction_matrix_df["p_ij"]
-                print("Probabilties in interaction matrix are treated as empirical probabilties")
+                
+                print("NOTE: Probabilities in interaction matrix are treated as empirical probabilities")
+                
             else:
-                print("Interaction matrix contains empirical probabilties")
+                
+                print("NOTE: Interaction matrix contains empirical probabilities")
 
             if "E_ij_emp" not in self.interaction_matrix_df.columns:
+                
                 self.interaction_matrix_df["E_ij_emp"] = self.interaction_matrix_df["E_ij"]
-                print("Customer interactions in interaction matrix are treated as empirical interactions")
+                
+                print("NOTE: Customer interactions in interaction matrix are treated as empirical interactions")
+                
             else:
-                print("Interaction matrix contains empirical customer interactions")
+                
+                print("NOTE: Interaction matrix contains empirical customer interactions")
 
             if np.isnan(ml_result.x).any():
 
-                print("No update of estimates because fit parameters contain NaN")
+                print("WARNING: No update of estimates because fit parameters contain NaN")
 
                 update_estimates = False
 
@@ -1351,7 +1344,7 @@ class InteractionMatrix:
             "update_estimates": update_estimates
             }
         
-        return self
+        return self    
 
     def update(self):
 
@@ -1367,12 +1360,12 @@ class InteractionMatrix:
         supply_locations_geodata_gpd_new = supply_locations_geodata_gpd[supply_locations_geodata_gpd["j_update"] == 1]
         
         if len(supply_locations_geodata_gpd_new) < 1:
-            raise ValueError("There are no new destinations for an interaction matrix update. Use SupplyLocations.add_new_destinations()")
+            raise ValueError("Error in InteractionMatrix update: There are no new destinations for an interaction matrix update. Use SupplyLocations.add_new_destinations()")
 
         supply_locations_geodata_gpd_original = supply_locations.get_geodata_gpd_original().copy()        
         supply_locations_geodata_gpd_original_new = supply_locations_geodata_gpd_original[supply_locations_geodata_gpd_original["j_update"] == 1]
         if len(supply_locations_geodata_gpd_original_new) < 1:
-            raise ValueError("There are no new destinations for an interaction matrix update. Use SupplyLocations.add_new_destinations()")
+            raise ValueError("Error in InteractionMatrix update: There are no new destinations for an interaction matrix update. Use SupplyLocations.add_new_destinations()")
 
         supply_locations_new = SupplyLocations(
             geodata_gpd=supply_locations_geodata_gpd_new,
@@ -1391,7 +1384,7 @@ class InteractionMatrix:
      
         if "transport_costs" not in interaction_matrix_metadata:
             
-            print("New destination(s) included. No transport costs calculation because not defined in original interaction matrix.")
+            print("WARNING: New destination(s) included. No transport costs calculation because not defined in original interaction matrix.")
             
             interaction_matrix_df = pd.concat(
                 [
@@ -1465,7 +1458,7 @@ class MarketAreas:
         ):
         
         if not isinstance(model_object, (HuffModel, MCIModel, InteractionMatrix)):
-            raise ValueError("Parameter 'interaction_matrix' must be of class HuffModel,  MCIModel, or InteractionMatrix")
+            raise ValueError("Error while adding MarketAreas to model: Parameter 'interaction_matrix' must be of class HuffModel,  MCIModel, or InteractionMatrix")
         
         if isinstance(model_object, MCIModel):
                         
@@ -1486,7 +1479,7 @@ class MarketAreas:
         elif isinstance(model_object, InteractionMatrix):
 
             if output_model not in ["Huff", "MCI"]:
-                raise ValueError("Parameter 'output_model' must be either 'Huff' or 'MCI'")
+                raise ValueError("Error while adding MarketAreas to model: Parameter 'output_model' must be either 'Huff' or 'MCI'")
             
             if output_model == "Huff":
 
@@ -1604,10 +1597,19 @@ class HuffModel:
                 else:
 
                     name = supply_locations_metadata["weighting"][key]["name"]
-                    param = supply_locations_metadata["weighting"][key]["param"]
                     func = supply_locations_metadata["weighting"][key]["func"]
 
-                    print(f"{name[:16]:16}    {round(param, 3)} ({func})")
+                    if "param" in supply_locations_metadata["weighting"][key]: 
+                    
+                        param = supply_locations_metadata["weighting"][key]["param"]
+                        
+                        if param is not None:
+
+                            print(f"{name[:16]:16}    {round(param, 3)} ({func})")
+
+                        else:
+
+                            print(f"{attrac_vars[key][:16]:16}    NA ({func})")
                     
         print("----------------------------------")
 
@@ -1625,7 +1627,6 @@ class HuffModel:
                 print ("Goodness-of-fit for " + interaction_matrix_metadata["fit"]["fit_by"])
                         
                 print("Sum of squared residuals       ", round(huff_modelfit[1]["SQR"], 2))
-                print("Sum of squares                 ", round(huff_modelfit[1]["SQT"], 2))
                 print("R-squared                      ", round(huff_modelfit[1]["Rsq"], 2))
                 print("Mean squared error             ", round(huff_modelfit[1]["MSE"], 2))
                 print("Root mean squared error        ", round(huff_modelfit[1]["RMSE"], 2))
@@ -1751,10 +1752,10 @@ class HuffModel:
             if isinstance(params, np.ndarray):
                 params = params.tolist()
             else:
-                raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+                raise ValueError("Error in loglik: Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
         
         if len(params) < 2:
-            raise ValueError("Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
+            raise ValueError("Error in loglik: Parameter 'params' must be a list or np.ndarray with at least 2 parameter values")
         
         market_areas_df = self.market_areas_df
         
@@ -1766,7 +1767,7 @@ class HuffModel:
         if customer_origins_metadata["weighting"][0]["func"] == "logistic":
             
             if len(params) < 3:
-                raise ValueError("When using logistic weighting, parameter 'params' must be a list or np.ndarray with at least 3 parameter values")
+                raise ValueError("Error in loglik: When using logistic weighting, parameter 'params' must be a list or np.ndarray with at least 3 parameter values")
         
             param_gamma, param_lambda, param_lambda2 = params[0], params[1], params[2]
 
@@ -1784,7 +1785,7 @@ class HuffModel:
             
             else:
                 
-                raise ValueError ("Huff Model with transport cost weighting of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 2 input parameters")
+                raise ValueError ("Error in loglik: Huff Model with transport cost weighting of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 2 input parameters")
         
         elif customer_origins_metadata["weighting"][0]["func"] == "logistic":
             
@@ -1794,7 +1795,7 @@ class HuffModel:
             
             else:
 
-                raise ValueError("Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 3 input parameters")
+                raise ValueError("Error in loglik: Huff Model with transport cost weightig of type " + customer_origins_metadata["weighting"][0]["func"] + " must have >= 3 input parameters")
 
         if (customer_origins_metadata["weighting"][0]["func"] in ["power", "exponential"] and len(params) > 2): 
             
@@ -1853,7 +1854,8 @@ class HuffModel:
         bounds: list = [(0.5, 1), (-3, -1)],        
         constraints: list = [],
         fit_by = "probabilities",
-        update_estimates: bool = True
+        update_estimates: bool = True,
+        check_numbers: bool = True
         ):
         
         if fit_by in ["probabilities", "flows"]:
@@ -1869,6 +1871,16 @@ class HuffModel:
         
         elif fit_by == "totals":
             
+            if check_numbers:
+                
+                market_areas_df = self.market_areas_df
+                interaction_matrix_df = self.get_interaction_matrix_df()
+                T_j_market_areas_df = sum(market_areas_df["T_j"])
+                T_j_interaction_matrix_df = sum(interaction_matrix_df["E_ij"])
+                
+                if T_j_market_areas_df != T_j_interaction_matrix_df:
+                    print("WARNING: Sum of total market areas (" + str(int(T_j_market_areas_df)) + ") is not equal to sum of customer flows (" + str(int(T_j_interaction_matrix_df)) + ")")
+            
             supply_locations = self.interaction_matrix.supply_locations
             supply_locations_metadata = supply_locations.get_metadata()
         
@@ -1894,10 +1906,10 @@ class HuffModel:
             params_metadata = params_metadata_customer_origins+params_metadata_supply_locations
 
             if len(initial_params) < 2 or len(initial_params) != params_metadata:
-                raise ValueError("Parameter 'initial_params' must be a list with " + str(params_metadata) + " entries (Attaction: " + str(params_metadata_supply_locations) + ", Transport costs: " + str(params_metadata_customer_origins) + ")")
+                raise ValueError("Error in ml_fit: Parameter 'initial_params' must be a list with " + str(params_metadata) + " entries (Attaction: " + str(params_metadata_supply_locations) + ", Transport costs: " + str(params_metadata_customer_origins) + ")")
             
             if len(bounds) != len(initial_params):            
-                raise ValueError("Parameter 'bounds' must have the same length as parameter 'initial_params' (" + str(len(bounds)) + ", " + str(len(initial_params)) + ")")
+                raise ValueError("Error in ml_fit: Parameter 'bounds' must have the same length as parameter 'initial_params' (" + str(len(bounds)) + ", " + str(len(initial_params)) + ")")
 
             ml_result = minimize(
                 self.loglik,
@@ -1986,12 +1998,13 @@ class HuffModel:
                     update_estimates = False
 
                 else:
-
+                                       
                     self.interaction_matrix.utility()
                     self.interaction_matrix.probabilities()
-                    self.interaction_matrix.flows()
+                    self.interaction_matrix.flows()                    
                     
-                    self.interaction_matrix.marketareas()
+                    huff_model_new_marketareas = self.interaction_matrix.marketareas()
+                    self.market_areas_df["T_j"] = huff_model_new_marketareas.get_market_areas_df()["T_j"]
             
             self.interaction_matrix.metadata["fit"] = {
                 "function": "huff_ml_fit",
@@ -2007,9 +2020,116 @@ class HuffModel:
             
         else:
 
-            raise ValueError("Parameter 'fit_by' must be 'probabilities', 'flows' or 'totals'")
+            raise ValueError("Error in ml_fit: Parameter 'fit_by' must be 'probabilities', 'flows' or 'totals'")
 
         return self
+    
+    def confint(
+        self,
+        alpha = 0.05,
+        repeats = 3,
+        sample_size = 0.75,
+        replace = True
+        ):
+        
+        if self.interaction_matrix.metadata["fit"] is None or self.interaction_matrix.metadata["fit"] == {}:
+            raise ValueError("Error while estimating confidence intervals: Model object does not contain information towards fit procedure")
+
+        keys_necessary = [
+            "function", 
+            "fit_by", 
+            "initial_params",
+            "method",
+            "bounds",
+            "constraints"            
+            ]
+
+        for key_necessary in keys_necessary:
+            if key_necessary not in self.interaction_matrix.metadata["fit"]:
+                raise KeyError(f"Error while estimating confidence intervals: Model object does not contain full information towards fit procedure. Missing key {key_necessary}")
+        
+        fitted_params_repeats = []
+
+        alpha_lower = alpha/2
+        alpha_upper = 1-alpha/2
+
+        huff_model_copy = copy.deepcopy(self)     
+
+        if self.interaction_matrix.metadata["fit"]["fit_by"] in ["probabilities", "flows"]:
+        
+            for i in range(repeats):
+                
+                try:
+                
+                    n_samples = int(len(huff_model_copy.interaction_matrix.interaction_matrix_df)*sample_size)
+                    
+                    huff_model_copy.interaction_matrix.interaction_matrix_df = huff_model_copy.interaction_matrix.interaction_matrix_df.sample(
+                        n = n_samples, 
+                        replace = replace
+                        )
+                    
+                    huff_model_copy.ml_fit(
+                        initial_params = self.interaction_matrix.metadata["fit"]["initial_params"],
+                        method = self.interaction_matrix.metadata["fit"]["method"],
+                        bounds = self.interaction_matrix.metadata["fit"]["bounds"],        
+                        constraints = self.interaction_matrix.metadata["fit"]["constraints"],
+                        fit_by = self.interaction_matrix.metadata["fit"]["fit_by"],
+                        update_estimates = True,
+                        check_numbers = True
+                    )
+                    
+                    minimize_fittedparams = huff_model_copy.interaction_matrix.metadata["fit"]["minimize_fittedparams"]
+                        
+                    fitted_params_repeats.append(minimize_fittedparams)
+
+                except Exception as err:
+
+                    print (f"Error in repeat {str(i)}: {err}")
+        
+        elif self.metadata["fit"]["fit_by"] == "totals":
+            
+            for i in range(repeats):
+
+                n_samples = int(len(huff_model_copy.market_areas_df)*sample_size)
+
+                huff_model_copy.market_areas_df = huff_model_copy.market_areas_df.sample(
+                    n = n_samples, 
+                    replace = replace
+                    )
+            
+                huff_model_copy.interaction_matrix.interaction_matrix_df = huff_model_copy.interaction_matrix.interaction_matrix_df[
+                    huff_model_copy.interaction_matrix.interaction_matrix_df["j"].isin(huff_model_copy.market_areas_df["j"])
+                    ]
+                
+                huff_model_copy.ml_fit(
+                    initial_params = self.interaction_matrix.metadata["fit"]["initial_params"],
+                    method = self.interaction_matrix.metadata["fit"]["method"],
+                    bounds = self.interaction_matrix.metadata["fit"]["bounds"],        
+                    constraints = self.interaction_matrix.metadata["fit"]["constraints"],
+                    fit_by = self.interaction_matrix.metadata["fit"]["fit_by"],
+                    update_estimates = True,
+                    check_numbers = True
+                )
+                
+                minimize_fittedparams = huff_model_copy.interaction_matrix.metadata["fit"]["minimize_fittedparams"]
+                    
+                fitted_params_repeats.append(minimize_fittedparams)
+
+        else:
+            
+            raise ValueError("Error while estimating confidence intervals: Parameter 'fit_by' must be 'probabilities', 'flows' or 'totals'")
+        
+        fitted_params_repeats_array = np.array(fitted_params_repeats)
+        fitted_params_repeats_array_transposed = fitted_params_repeats_array.T
+        
+        param_ci = pd.DataFrame(columns=["lower", "upper"])
+
+        for i, col in enumerate(fitted_params_repeats_array_transposed):
+            
+            param_ci.loc[i, "lower"] = np.quantile(col, alpha_lower)
+            param_ci.loc[i, "upper"] = np.quantile(col, alpha_upper)
+        
+        return param_ci
 
     def update(self):
         
@@ -2042,12 +2162,12 @@ class HuffModel:
                     
                 except:
                     
-                    print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    print("WARNING: Goodness-of-fit metrics could not be calculated due to NaN values.")
                     return None
             
             else:
                 
-                print("Goodness-of-fit metrics could not be calculated. No empirical values of probabilities in interaction matrix.")
+                print("WARNING: Goodness-of-fit metrics could not be calculated. No empirical values of probabilities in interaction matrix.")
 
                 return None
             
@@ -2069,12 +2189,12 @@ class HuffModel:
                     
                 except:
                     
-                    print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    print("WARNING: Goodness-of-fit metrics could not be calculated due to NaN values.")
                     return None
             
             else:
                 
-                print("Goodness-of-fit metrics could not be calculated. No empirical values of customer flows in interaction matrix.")
+                print("WARNING: Goodness-of-fit metrics could not be calculated. No empirical values of customer flows in interaction matrix.")
 
                 return None
             
@@ -2095,18 +2215,18 @@ class HuffModel:
                     
                 except:
                     
-                    print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                    print("WARNING: Goodness-of-fit metrics could not be calculated due to NaN values.")
                     return None
                 
             else:
                 
-                print("Goodness-of-fit metrics could not be calculated. No empirical values of T_j in market areas data.")
+                print("WARNING: Goodness-of-fit metrics could not be calculated. No empirical values of T_j in market areas data.")
 
                 return None
 
         else:
 
-            raise ValueError("Parameter 'by' must be 'probabilities', 'flows', or 'totals'")
+            raise ValueError("Error in HuffModel.modelfit: Parameter 'by' must be 'probabilities', 'flows', or 'totals'")
     
 class MCIModel:
 
@@ -2174,7 +2294,7 @@ class MCIModel:
                 
             except:
                 
-                print("Goodness-of-fit metrics could not be calculated due to NaN values.")
+                print("WARNING: Goodness-of-fit metrics could not be calculated due to NaN values.")
                 return None
         
         else:
@@ -2224,7 +2344,6 @@ class MCIModel:
             print ("Goodness-of-fit for probabilities")
                     
             print("Sum of squared residuals       ", round(mci_modelfit[1]["SQR"], 2))
-            print("Sum of squares                 ", round(mci_modelfit[1]["SQT"], 2))
             print("R-squared                      ", round(mci_modelfit[1]["Rsq"], 2))
             print("Mean squared error             ", round(mci_modelfit[1]["MSE"], 2))
             print("Root mean squared error        ", round(mci_modelfit[1]["RMSE"], 2))
@@ -2261,9 +2380,9 @@ class MCIModel:
         interaction_matrix_metadata = interaction_matrix.get_metadata()
 
         if interaction_matrix_df["t_ij"].isna().all():
-            raise ValueError ("Transport cost variable is not defined")
+            raise ValueError ("Error in utility calculation: Transport cost variable is not defined")
         if interaction_matrix_df["A_j"].isna().all():
-            raise ValueError ("Attraction variable is not defined")
+            raise ValueError ("Error in utility calculation: Attraction variable is not defined")
 
         check_vars(
             df = interaction_matrix_df,
@@ -2364,10 +2483,10 @@ class MCIModel:
         interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
 
         if "C_i" not in interaction_matrix_df.columns:
-            raise ValueError ("No market size column defined in interaction matrix.")
+            raise ValueError ("Error in flows calculation: No market size column defined in interaction matrix.")
         
         if interaction_matrix_df["C_i"].isna().all():
-            raise ValueError ("Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
+            raise ValueError ("Error in flows calculation: Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
 
         check_vars(
             df = interaction_matrix_df,
@@ -2422,12 +2541,12 @@ def load_geodata (
     ):
 
     if location_type is None or (location_type != "origins" and location_type != "destinations"):
-        raise ValueError ("Argument location_type must be either 'origins' or 'destinations'")
+        raise ValueError ("Error while loading geodata: Argument location_type must be either 'origins' or 'destinations'")
 
     if isinstance(data, gp.GeoDataFrame):
         geodata_gpd_original = data
         if not all(geodata_gpd_original.geometry.geom_type == "Point"):
-            raise ValueError ("Input geopandas.GeoDataFrame must be of type 'Point'")
+            raise ValueError ("Error while loading geodata: Input geopandas.GeoDataFrame must be of type 'Point'")
         crs_input = geodata_gpd_original.crs
     elif isinstance(data, pd.DataFrame):
         geodata_tab = data
@@ -2435,13 +2554,13 @@ def load_geodata (
         if data_type == "shp":
             geodata_gpd_original = gp.read_file(data)
             if not all(geodata_gpd_original.geometry.geom_type == "Point"):
-                raise ValueError ("Input shapefile must be of type 'Point'")
+                raise ValueError ("Error while loading geodata: Input shapefile must be of type 'Point'")
             crs_input = geodata_gpd_original.crs
         elif data_type == "csv" or data_type == "xlsx":
             if x_col is None:
-                raise ValueError ("Missing value for X coordinate column")
+                raise ValueError ("Error while loading geodata: Missing value for X coordinate column")
             if y_col is None:
-                raise ValueError ("Missing value for Y coordinate column")
+                raise ValueError ("Error while loading geodata: Missing value for Y coordinate column")
         elif data_type == "csv":
             geodata_tab = pd.read_csv(
                 data, 
@@ -2452,9 +2571,9 @@ def load_geodata (
         elif data_type == "xlsx":
             geodata_tab = pd.read_excel(data)
         else:
-            raise TypeError("Unknown type of data")
+            raise TypeError("Error while loading geodata: Unknown type of data")
     else:
-        raise TypeError("data must be pandas.DataFrame, geopandas.GeoDataFrame or file (.csv, .xlsx, .shp)")
+        raise TypeError("Error while loading geodata: Param 'data' must be pandas.DataFrame, geopandas.GeoDataFrame or file (.csv, .xlsx, .shp)")
 
     if data_type == "csv" or data_type == "xlsx" or (isinstance(data, pd.DataFrame) and not isinstance(data, gp.GeoDataFrame)):
         
@@ -2525,17 +2644,17 @@ def create_interaction_matrix(
     ):
 
     if not isinstance(customer_origins, CustomerOrigins):
-        raise ValueError ("customer_origins must be of class CustomerOrigins")
+        raise ValueError ("Error while creating interaction matrix: customer_origins must be of class CustomerOrigins")
     if not isinstance(supply_locations, SupplyLocations):
-        raise ValueError ("supply_locations must be of class SupplyLocations")
+        raise ValueError ("Error while creating interaction matrix: supply_locations must be of class SupplyLocations")
 
     customer_origins_metadata = customer_origins.get_metadata()
     if customer_origins_metadata["marketsize_col"] is None:
-        raise ValueError("Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
+        raise ValueError("Error while creating interaction matrix: Market size column in customer origins not defined. Use CustomerOrigins.define_marketsize()")
     
     supply_locations_metadata = supply_locations.get_metadata()
     if supply_locations_metadata["attraction_col"][0] is None:
-        raise ValueError("Attraction column in supply locations not defined. Use SupplyLocations.define_attraction()")
+        raise ValueError("Error while creating interaction matrix: Attraction column in supply locations not defined. Use SupplyLocations.define_attraction()")
 
     customer_origins_unique_id = customer_origins_metadata["unique_id"]
     customer_origins_marketsize = customer_origins_metadata["marketsize_col"]
@@ -2623,7 +2742,7 @@ def load_interaction_matrix(
         interaction_matrix_df = data
     elif isinstance(data, str):
         if data_type not in ["csv", "xlsx"]:
-            raise ValueError ("data_type must be 'csv' or 'xlsx'")
+            raise ValueError ("Error while loading interaction matrix: param 'data_type' must be 'csv' or 'xlsx'")
         if data_type == "csv":
             interaction_matrix_df = pd.read_csv(
                 data, 
@@ -2640,14 +2759,14 @@ def load_interaction_matrix(
             else:
                 interaction_matrix_df = pd.read_excel(data)
         else:
-            raise TypeError("Unknown type of data")
+            raise TypeError("Error while loading interaction matrix: Unknown type of data")
     else:
-        raise TypeError("data must be pandas.DataFrame or file (.csv, .xlsx)")
+        raise TypeError("Error while loading interaction matrix: param 'data' must be pandas.DataFrame or file (.csv, .xlsx)")
     
     if customer_origins_col not in interaction_matrix_df.columns:
-        raise KeyError ("Column " + customer_origins_col + " not in data")
+        raise KeyError ("Error while loading interaction matrix: Column " + customer_origins_col + " not in data")
     if supply_locations_col not in interaction_matrix_df.columns:
-        raise KeyError ("Column " + supply_locations_col + " not in data")
+        raise KeyError ("Error while loading interaction matrix: Column " + supply_locations_col + " not in data")
     
     cols_check = attraction_col + [transport_costs_col]
     if flows_col is not None:
@@ -2668,7 +2787,7 @@ def load_interaction_matrix(
         if isinstance(customer_origins_coords_col, str):
 
             if customer_origins_coords_col not in interaction_matrix_df.columns:
-                raise KeyError ("Column " + customer_origins_coords_col + " not in data.")    
+                raise KeyError ("Error while loading interaction matrix: Column " + customer_origins_coords_col + " not in data.")    
             
             customer_origins_geodata_tab = interaction_matrix_df[[customer_origins_col, customer_origins_coords_col]]
             customer_origins_geodata_tab = customer_origins_geodata_tab.drop_duplicates()
@@ -2684,7 +2803,7 @@ def load_interaction_matrix(
         elif isinstance(customer_origins_coords_col, list):
 
             if len(customer_origins_coords_col) != 2:
-                raise ValueError ("Column " + customer_origins_coords_col + " must be a geometry column OR TWO columns with X and Y")
+                raise ValueError ("Error while loading interaction matrix: Column " + customer_origins_coords_col + " must be a geometry column OR TWO columns with X and Y")
             
             check_vars (
                 df = interaction_matrix_df, 
@@ -2739,7 +2858,7 @@ def load_interaction_matrix(
         if isinstance(supply_locations_coords_col, str):
 
             if supply_locations_coords_col not in interaction_matrix_df.columns:
-                raise KeyError ("Column " + supply_locations_coords_col + " not in data.")    
+                raise KeyError ("Error while loading interaction matrix: Column " + supply_locations_coords_col + " not in data.")    
             
             supply_locations_geodata_tab = interaction_matrix_df[[supply_locations_col, supply_locations_coords_col]]
             supply_locations_geodata_tab = supply_locations_geodata_tab.drop_duplicates()
@@ -2755,7 +2874,7 @@ def load_interaction_matrix(
         if isinstance(supply_locations_coords_col, list):
 
             if len(supply_locations_coords_col) != 2:
-                raise ValueError ("Column " + supply_locations_coords_col + " must be a geometry column OR TWO columns with X and Y")
+                raise ValueError ("Error while loading interaction matrix: Column " + supply_locations_coords_col + " must be a geometry column OR TWO columns with X and Y")
             
             check_vars (
                 df = interaction_matrix_df, 
@@ -2864,7 +2983,7 @@ def load_marketareas(
         market_areas_df = data
     elif isinstance(data, str):
         if data_type not in ["csv", "xlsx"]:
-            raise ValueError ("data_type must be 'csv' or 'xlsx'")
+            raise ValueError ("Error while loading market areas: data_type must be 'csv' or 'xlsx'")
         if data_type == "csv":
             market_areas_df = pd.read_csv(
                 data, 
@@ -2881,14 +3000,14 @@ def load_marketareas(
             else:
                 market_areas_df = pd.read_excel(data)
         else:
-            raise TypeError("Unknown type of data")
+            raise TypeError("Error while loading market areas: Unknown type of data")
     else:
-        raise TypeError("data must be pandas.DataFrame or file (.csv, .xlsx)")
+        raise TypeError("Error while loading market areas: data must be pandas.DataFrame or file (.csv, .xlsx)")
     
     if supply_locations_col not in market_areas_df.columns:
-        raise KeyError ("Column " + supply_locations_col + " not in data")
+        raise KeyError ("Error while loading market areas: Column " + supply_locations_col + " not in data")
     if total_col not in market_areas_df.columns:
-        raise KeyError ("Column " + supply_locations_col + " not in data")
+        raise KeyError ("Error while loading market areas: Column " + supply_locations_col + " not in data")
     
     if check_df_vars:
         check_vars(
@@ -2931,7 +3050,7 @@ def market_shares(
     if ref_col is not None:
 
         if ref_col not in df.columns:
-            raise KeyError(f"Column '{ref_col}' not in dataframe.")
+            raise KeyError(f"Error while calculating market shares: Column '{ref_col}' not in dataframe.")
         
         ms_refcol = pd.DataFrame(df.groupby(ref_col)[turnover_col].sum())
         ms_refcol = ms_refcol.rename(columns = {turnover_col: "total"})
@@ -2979,7 +3098,7 @@ def log_centering_transformation(
         )
     
     if ref_col not in df.columns:
-        raise KeyError(f"Column '{ref_col}' not in dataframe.")
+        raise KeyError(f"Error in log-centering transformation: Column '{ref_col}' not in dataframe.")
 
     def lct (x):
 
@@ -3107,17 +3226,20 @@ def modelfit(
     expected_no = len(expected)
 
     if not observed_no == expected_no:
-        raise ValueError("Observed and expected differ in length")
+        raise ValueError("Error while calculating fit metrics: Observed and expected differ in length")
     
     if not isinstance(observed, np.number): 
         if not is_numeric_dtype(observed):
-            raise ValueError("Observed column is not numeric")
+            raise ValueError("Error while calculating fit metrics: Observed column is not numeric")
     if not isinstance(expected, np.number):
         if not is_numeric_dtype(expected):
-            raise ValueError("Expected column is not numeric")
+            raise ValueError("Error while calculating fit metrics: Expected column is not numeric")
     
     if remove_nan:
         
+        observed = observed.reset_index(drop=True)
+        expected = expected.reset_index(drop=True)
+
         obs_exp = pd.DataFrame(
             {
                 "observed": observed, 
@@ -3129,7 +3251,7 @@ def modelfit(
 
         if len(obs_exp_clean) < len(observed) or len(obs_exp_clean) < len(expected):
             if verbose:
-                print("Vectors 'observed' and/or 'expected' contain zeros which are dropped.")
+                print("NOTE: Vectors 'observed' and/or 'expected' contain zeros which are dropped.")
         
         observed = obs_exp_clean["observed"].to_numpy()
         expected = obs_exp_clean["expected"].to_numpy()
@@ -3137,9 +3259,9 @@ def modelfit(
     else:
         
         if np.isnan(observed).any():
-            raise ValueError("Vector with observed data contains NaN")
+            raise ValueError("Error while calculating fit metrics: Vector with observed data contains NaN and 'remove_nan' is False")
         if np.isnan(expected).any():
-            raise ValueError("Vector with expected data contains NaN")
+            raise ValueError("Error while calculating fit metrics: Vector with expected data contains NaN and 'remove_nan' is False")
     
     residuals = np.array(observed)-np.array(expected)
     residuals_sq = residuals**2

huff/tests/tests_huff.py

@@ -4,12 +4,13 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.5.1
-# Last update: 2025-07-01 17:10
+# Version:     1.5.3
+# Last update: 2025-07-15 17:22
 # Copyright (c) 2025 Thomas Wieland
 #-----------------------------------------------------------------------
 
 from huff.models import create_interaction_matrix, get_isochrones, load_geodata, load_interaction_matrix, load_marketareas, market_shares, modelfit
+from huff.models import HuffModel
 from huff.osm import map_with_basemap
 from huff.gistools import buffers, point_spatial_join
 
@@ -140,6 +141,10 @@ huff_model_fit = haslach_interactionmatrix.marketareas()
 # Calculcation of total market areas
 # Result of class HuffModel
 
+bootstrap_cis = huff_model_fit.confint(repeats=10)
+print(bootstrap_cis)
+# Confidence intervals for estimated parameters
+
 huff_model_fit.summary()
 # Huff model summary
 
@@ -354,6 +359,9 @@ huff_model_fit3 = huff_model_fit2.ml_fit(
 huff_model_fit3.summary()
 # Show summary
 
+print(huff_model_fit3.get_market_areas_df())
+# Show market areas df
+
 
 # Buffer analysis:
 

{huff-1.5.1.dist-info → huff-1.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: huff
-Version: 1.5.1
+Version: 1.5.3
 Summary: huff: Huff Model Market Area Analysis
 Author: Thomas Wieland
 Author-email: geowieland@googlemail.com
@@ -18,7 +18,7 @@ Requires-Dist: openpyxl
 
 # huff: Huff Model Market Area Analysis
 
-This Python library is designed for performing market area analyses with the Huff Model (Huff 1962, 1964) and/or the Multiplicative Competitive Interaction (MCI) Model (Nakanishi and Cooper 1974, 1982). Users may load point shapefiles (or CSV, XLSX) of customer origins and supply locations and conduct a market area analysis step by step. The package also includes supplementary GIS functions, including clients for OpenRouteService(1) for network analysis (e.g., transport cost matrix) and OpenStreetMap(2) for simple maps. See Huff and McCallum (2008) or Wieland (2017) for a description of the models and their practical application. 
+This Python library is designed for performing market area analyses with the Huff Model (Huff 1962, 1964) and/or the Multiplicative Competitive Interaction (MCI) Model (Nakanishi and Cooper 1974, 1982). Users may load point shapefiles (or CSV, XLSX) of customer origins and supply locations and conduct a market area analysis step by step. The library supports parameter estimation based on empirical customer data using the MCI model and Maximum Likelihood. The package also includes supplementary GIS functions, including clients for OpenRouteService(1) for network analysis (e.g., transport cost matrix) and OpenStreetMap(2) for simple maps. See Huff and McCallum (2008) or Wieland (2017) for a description of the models and their practical application. 
 
 
 ## Author
@@ -28,14 +28,12 @@ Thomas Wieland [ORCID](https://orcid.org/0000-0001-5168-9846) [EMail](mailto:geo
 See the /tests directory for usage examples of most of the included functions.
 
 
-## Updates v1.5.1
-- Extensions:
-  - HuffModel.ml_fit(): Fit Huff model parameters by empirical total market areas
-  - HuffModel.summary(): Goodnes-of-fit depends on fit_by
-  - load_market_areas(): Loading table with totals and including into InteractionMatrix, HuffModel and MCIModel objects
+## Updates v1.5.3
 - Bugfixes:
-  - InteractionMatrix.summary(): NoneType parameter
-  - InteractionMatrix.huff_ml_fit(): Update estimates possible even if fit algorithm did not converge
+  - InteractionMatrix.summary() and HuffModel.summary(): No KeyError when param is None anymore
+- Extensions:
+  - Confidence intervals (bootstrap) for Huff Model ML estimations
+  - ValueError and KeyError are more precise (function is included)
   
 
 ## Features
@@ -44,7 +42,7 @@ See the /tests directory for usage examples of most of the included functions.
   - Defining origins and destinations with weightings
   - Creating interaction matrix from origins and destinations
   - Different function types: power, exponential, logistic
-  - Huff model parameter estimation via Maximum Likelihood (ML) by probalities and customer flows
+  - Huff model parameter estimation via Maximum Likelihood (ML) by probalities, customer flows, and total market areas
   - Huff model market simulation
 - **Multiplicative Competitive Interaction Model**: 
   - Log-centering transformation of interaction matrix

{huff-1.5.1.dist-info → huff-1.5.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
 huff/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 huff/gistools.py,sha256=fgeE1IsUO7UIaawb23kuiz_Rlxn7T18iLLTA5yvgp74,7038
-huff/models.py,sha256=IihaZmutJjdKqzTVXGVmcYbauFJImF-UPsZ2QCPzw8s,125182
+huff/models.py,sha256=mPASlL0YA8x-cnhoRgrpr1sP-p5gGg1_cwM-QGf8GfU,133310
 huff/ors.py,sha256=JlO2UEishQX87PIiktksOrVT5QdB-GEWgjXcxoR_KuA,11929
 huff/osm.py,sha256=9A-7hxeZyjA2r8w2_IqqwH14qq2Y9AS1GxVKOD7utqs,7747
 huff/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-huff/tests/tests_huff.py,sha256=eHnEiV8m7TjpAXnJqo1aZ0YlQCGHxK1iFXROEyhN5cU,12884
+huff/tests/tests_huff.py,sha256=FMnkSs7id4KcJei71DRLNPbY7cvOVjALwYzcBKCm1Ao,13116
 huff/tests/data/Haslach.cpg,sha256=OtMDH1UDpEBK-CUmLugjLMBNTqZoPULF3QovKiesmCQ,5
 huff/tests/data/Haslach.dbf,sha256=GVPIt05OzDO7UrRDcsMhiYWvyXAPg6Z-qkiysFzj-fc,506
 huff/tests/data/Haslach.prj,sha256=2Jy1Vlzh7UxQ1MXpZ9UYLs2SxfrObj2xkEkZyLqmGTY,437
@@ -23,8 +23,8 @@ huff/tests/data/Haslach_supermarkets.prj,sha256=2Jy1Vlzh7UxQ1MXpZ9UYLs2SxfrObj2x
 huff/tests/data/Haslach_supermarkets.qmd,sha256=JlcOYzG4vI1NH1IuOpxwIPnJsCyC-pDRAI00TzEvNf0,2522
 huff/tests/data/Haslach_supermarkets.shp,sha256=X7QbQ0BTMag_B-bDRbpr-go2BQIXo3Y8zMAKpYZmlps,324
 huff/tests/data/Haslach_supermarkets.shx,sha256=j23QHX-SmdAeN04rw0x8nUOran-OCg_T6r_LvzzEPWs,164
-huff/tests/data/Wieland2015.xlsx,sha256=jUt9YcRrYL99AjxzXKMXD3o5erjd9r_jYfnALdrTQ3o,24333
-huff-1.5.1.dist-info/METADATA,sha256=BXRKyUp5qIEoYjNpo_w9zpUwMTDTO_aegNgr67qj8ns,6187
-huff-1.5.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-huff-1.5.1.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
-huff-1.5.1.dist-info/RECORD,,
+huff/tests/data/Wieland2015.xlsx,sha256=H4rxCFlctn44-O6mIyeFf67FlgvznLX7xZqpoWYS41A,25788
+huff-1.5.3.dist-info/METADATA,sha256=vqlH9tlDz5pHu85fYu1Bnprk9yiWzAPRY94rQTQxFGM,6142
+huff-1.5.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+huff-1.5.3.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
+huff-1.5.3.dist-info/RECORD,,