huff 1.5.2__py3-none-any.whl → 1.5.4__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.2
-# Last update: 2025-07-02 21:09
+# Version:     1.5.4
+# Last update: 2025-07-18 18:07
 # 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()
@@ -766,25 +766,29 @@ class InteractionMatrix:
         self.supply_locations.metadata = supply_locations_metadata
         self.customer_origins.metadata = customer_origins_metadata
 
-    def utility(self):
+    def utility(
+        self,
+        check_df_vars: bool = True
+        ):
         
         interaction_matrix_df = self.interaction_matrix_df
 
         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,
-            cols = ["A_j", "t_ij"]
-            )
+        if check_df_vars:
+            check_vars(
+                df = interaction_matrix_df,
+                cols = ["A_j", "t_ij"]
+                )
         
         customer_origins = self.customer_origins
         customer_origins_metadata = customer_origins.get_metadata()
@@ -793,11 +797,11 @@ class InteractionMatrix:
         if tc_weighting["func"] == "power":
             interaction_matrix_df["t_ij_weighted"] = interaction_matrix_df["t_ij"] ** tc_weighting["param"]
         elif tc_weighting["func"] == "exponential":
-            interaction_matrix_df["t_ij_weighted"] = np.exp(tc_weighting["param"] * interaction_matrix_df['t_ij'])
+            interaction_matrix_df["t_ij_weighted"] = np.exp(tc_weighting["param"] * interaction_matrix_df["t_ij"])
         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'])
+            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 +812,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)
@@ -818,8 +822,8 @@ class InteractionMatrix:
             
             for key, attrac_var in enumerate(attrac_vars):
                 
-                attrac_var_key = key #+1
-                if attrac_var_key == 0: #1:
+                attrac_var_key = key
+                if attrac_var_key == 0:
                     continue
                 
                 name = supply_locations_metadata["weighting"][attrac_var_key]["name"]
@@ -831,7 +835,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"]
 
@@ -850,7 +854,10 @@ class InteractionMatrix:
         
         return self
     
-    def probabilities (self):
+    def probabilities (
+        self,
+        check_df_vars: bool = True
+        ):
 
         interaction_matrix_df = self.interaction_matrix_df
 
@@ -858,6 +865,12 @@ class InteractionMatrix:
             self.utility()
             interaction_matrix_df = self.interaction_matrix_df
 
+        if check_df_vars:
+            check_vars(
+                df = interaction_matrix_df,
+                cols = ["U_ij"]
+                )
+
         utility_i = pd.DataFrame(interaction_matrix_df.groupby("i")["U_ij"].sum())
         utility_i = utility_i.rename(columns = {"U_ij": "U_i"})
 
@@ -876,19 +889,23 @@ class InteractionMatrix:
 
         return self
         
-    def flows (self):
+    def flows (
+        self,
+        check_df_vars: bool = True
+        ):
 
         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,
-            cols = ["C_i"]
-            )
+        if check_df_vars:
+            check_vars(
+                df = interaction_matrix_df,
+                cols = ["C_i"]
+                )
 
         if interaction_matrix_df["p_ij"].isna().all():
             self.probabilities()
@@ -900,15 +917,19 @@ class InteractionMatrix:
 
         return self
 
-    def marketareas(self):
+    def marketareas(
+        self,
+        check_df_vars: bool = True
+        ):
 
         interaction_matrix_df = self.interaction_matrix_df
         
-        check_vars(
-            df = interaction_matrix_df,
-            cols = ["E_ij"],
-            check_zero = False
-            )
+        if check_df_vars:
+            check_vars(
+                df = interaction_matrix_df,
+                cols = ["E_ij"],
+                check_zero = False
+                )
         
         market_areas_df = pd.DataFrame(interaction_matrix_df.groupby("j")["E_ij"].sum())
         market_areas_df = market_areas_df.reset_index(drop=False)
@@ -940,18 +961,18 @@ 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]
             if tc_weighting["func"] == "power":
                 interaction_matrix_df["t_ij_weighted"] = interaction_matrix_df["t_ij"] ** tc_weighting["param"]
             elif tc_weighting["func"] == "exponential":
-                interaction_matrix_df["t_ij_weighted"] = np.exp(tc_weighting["param"] * interaction_matrix_df['t_ij'])
+                interaction_matrix_df["t_ij_weighted"] = np.exp(tc_weighting["param"] * interaction_matrix_df["t_ij"])
             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'])
+                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()
@@ -1073,20 +1094,21 @@ class InteractionMatrix:
     def loglik(
         self,
         params,
-        fit_by = "probabilities"
+        fit_by = "probabilities",
+        check_df_vars: bool = True
         ):
         
         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 +1118,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 +1138,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 +1148,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): 
             
@@ -1160,9 +1182,9 @@ class InteractionMatrix:
         
         interaction_matrix_copy = copy.deepcopy(self)
 
-        interaction_matrix_copy.utility()
-        interaction_matrix_copy.probabilities()
-        interaction_matrix_copy.flows()
+        interaction_matrix_copy.utility(check_df_vars = check_df_vars)
+        interaction_matrix_copy.probabilities(check_df_vars = check_df_vars)
+        interaction_matrix_copy.flows(check_df_vars = check_df_vars)
 
         interaction_matrix_df_copy = interaction_matrix_copy.get_interaction_matrix_df()
         
@@ -1196,7 +1218,8 @@ class InteractionMatrix:
         bounds: list = [(0.5, 1), (-3, -1)],        
         constraints: list = [],
         fit_by = "probabilities",
-        update_estimates: bool = True
+        update_estimates: bool = True,
+        check_df_vars: bool = True
         ):       
 
         supply_locations = self.supply_locations
@@ -1224,15 +1247,15 @@ 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,
             initial_params,
-            args=fit_by,
+            args=(fit_by, check_df_vars),
             method = method,
             bounds = bounds,
             constraints = constraints,
@@ -1344,7 +1367,7 @@ class InteractionMatrix:
             "update_estimates": update_estimates
             }
         
-        return self
+        return self    
 
     def update(self):
 
@@ -1360,12 +1383,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,
@@ -1458,7 +1481,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):
                         
@@ -1479,7 +1502,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":
 
@@ -1597,10 +1620,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("----------------------------------")
 
@@ -1736,17 +1768,18 @@ class HuffModel:
 
     def loglik(
         self,
-        params
+        params,
+        check_df_vars: bool = True
         ):
 
         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")
         
         market_areas_df = self.market_areas_df
         
@@ -1758,7 +1791,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]
 
@@ -1776,7 +1809,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":
             
@@ -1786,7 +1819,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): 
             
@@ -1818,9 +1851,9 @@ class HuffModel:
 
         interaction_matrix_copy = copy.deepcopy(huff_model_copy.interaction_matrix)
 
-        interaction_matrix_copy = interaction_matrix_copy.utility()
-        interaction_matrix_copy = interaction_matrix_copy.probabilities()
-        interaction_matrix_copy = interaction_matrix_copy.flows()
+        interaction_matrix_copy = interaction_matrix_copy.utility(check_df_vars = check_df_vars)
+        interaction_matrix_copy = interaction_matrix_copy.probabilities(check_df_vars = check_df_vars)
+        interaction_matrix_copy = interaction_matrix_copy.flows(check_df_vars = check_df_vars)
 
         huff_model_copy = interaction_matrix_copy.marketareas()
 
@@ -1846,7 +1879,8 @@ class HuffModel:
         constraints: list = [],
         fit_by = "probabilities",
         update_estimates: bool = True,
-        check_numbers: bool = True
+        check_numbers: bool = True,
+        check_df_vars: bool = True
         ):
         
         if fit_by in ["probabilities", "flows"]:
@@ -1857,7 +1891,8 @@ class HuffModel:
                 bounds = bounds,        
                 constraints = constraints,
                 fit_by = fit_by,
-                update_estimates = update_estimates
+                update_estimates = update_estimates,
+                check_df_vars = check_df_vars
                 )
         
         elif fit_by == "totals":
@@ -1897,14 +1932,15 @@ 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,
                 initial_params,
+                args=check_df_vars,
                 method = method,
                 bounds = bounds,
                 constraints = constraints,
@@ -1990,11 +2026,11 @@ class HuffModel:
 
                 else:
                                        
-                    self.interaction_matrix.utility()
-                    self.interaction_matrix.probabilities()
-                    self.interaction_matrix.flows()                    
+                    self.interaction_matrix.utility(check_df_vars = check_df_vars)
+                    self.interaction_matrix.probabilities(check_df_vars = check_df_vars)
+                    self.interaction_matrix.flows(check_df_vars = check_df_vars) 
                     
-                    huff_model_new_marketareas = self.interaction_matrix.marketareas()
+                    huff_model_new_marketareas = self.interaction_matrix.marketareas(check_df_vars = check_df_vars)
                     self.market_areas_df["T_j"] = huff_model_new_marketareas.get_market_areas_df()["T_j"]
             
             self.interaction_matrix.metadata["fit"] = {
@@ -2011,9 +2047,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):
         
@@ -2110,7 +2253,7 @@ class HuffModel:
 
         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:
 
@@ -2256,7 +2399,8 @@ class MCIModel:
                   
     def utility(
         self,
-        transformation = "LCT"
+        transformation = "LCT",
+        check_df_vars: bool = True
         ):
         
         interaction_matrix = self.interaction_matrix        
@@ -2264,14 +2408,15 @@ 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,
-            cols = ["A_j", "t_ij"]
-            )
+        if check_df_vars:
+            check_vars(
+                df = interaction_matrix_df,
+                cols = ["A_j", "t_ij"]
+                )
 
         customer_origins = interaction_matrix.get_customer_origins()
         customer_origins_metadata = customer_origins.get_metadata()
@@ -2360,22 +2505,24 @@ class MCIModel:
         
     def flows (
         self,
-        transformation = "LCT"
+        transformation = "LCT",
+        check_df_vars: bool = True
         ):
 
         interaction_matrix = self.interaction_matrix
         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,
-            cols = ["C_i"]
-            )
+        if check_df_vars:
+            check_vars(
+                df = interaction_matrix_df,
+                cols = ["C_i"]
+                )
 
         if interaction_matrix_df["p_ij"].isna().all():
             self.probabilities(transformation=transformation)
@@ -2388,15 +2535,19 @@ class MCIModel:
 
         return self
 
-    def marketareas (self):
+    def marketareas (
+        self,
+        check_df_vars: bool = True
+        ):
 
         interaction_matrix = self.interaction_matrix
         interaction_matrix_df = interaction_matrix.get_interaction_matrix_df()
         
-        check_vars(
-            df = interaction_matrix_df,
-            cols = ["E_ij"]
-            )
+        if check_df_vars:
+            check_vars(
+                df = interaction_matrix_df,
+                cols = ["E_ij"]
+                )
         
         market_areas_df = pd.DataFrame(interaction_matrix_df.groupby("j")["E_ij"].sum())
         market_areas_df = market_areas_df.reset_index(drop=False)
@@ -2425,12 +2576,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
@@ -2438,13 +2589,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, 
@@ -2455,9 +2606,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)):
         
@@ -2528,17 +2679,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"]
@@ -2619,14 +2770,14 @@ def load_interaction_matrix(
     xlsx_sheet: str = None,
     crs_input = "EPSG:4326",
     crs_output = "EPSG:4326",
-    check_df_vars = True
+    check_df_vars: bool = True
     ):    
 
     if isinstance(data, pd.DataFrame):
         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, 
@@ -2643,14 +2794,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:
@@ -2671,7 +2822,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()
@@ -2687,7 +2838,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, 
@@ -2742,7 +2893,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()
@@ -2758,7 +2909,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, 
@@ -2860,14 +3011,14 @@ def load_marketareas(
     csv_decimal = ",", 
     csv_encoding="unicode_escape",
     xlsx_sheet: str = None,
-    check_df_vars = True
+    check_df_vars: bool = True
     ):    
 
     if isinstance(data, pd.DataFrame):
         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, 
@@ -2884,14 +3035,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(
@@ -2934,7 +3085,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"})
@@ -2982,7 +3133,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):
 
@@ -3110,17 +3261,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, 
@@ -3140,9 +3294,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.2
-# Last update: 2025-07-02 21:10
+# Version:     1.5.4
+# Last update: 2025-07-18 18:06
 # 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
 

{huff-1.5.2.dist-info → huff-1.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: huff
-Version: 1.5.2
+Version: 1.5.4
 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,10 +28,10 @@ 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.2
+## Updates v1.5.4
 - Bugfixes:
-  - HuffModel.ml_fit(): Correct values of expected T_j, corrected calculation of model fit metrices when fit_by="totals"
-  - HuffModel.ml_fit(): Check if sum of E_ij != sum of T_j
+  - Use of check_vars() is now optional (default: True)
+  - Correction of args argument when calling minimize() in huff_ml_fit() 
   
 
 ## Features

{huff-1.5.2.dist-info → huff-1.5.4.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=e8aILi45qcJ9tvHJfKIFKWfD-DYXjZQ0gXOS4MpG7Ks,125430
+huff/models.py,sha256=2s-NQoPuP8q7iwJK3tA6S9-qDGMgRGah9vgL4aJerrU,134607
 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=xHCR087rqLNWDFfZhi1giKDzffCx3IemWQmHrAUYxFw,12956
+huff/tests/tests_huff.py,sha256=np0YvzmGYqVFCPFBsdFuUWtGlwX6HKUUlWkYlfWzGPY,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
@@ -24,7 +24,7 @@ huff/tests/data/Haslach_supermarkets.qmd,sha256=JlcOYzG4vI1NH1IuOpxwIPnJsCyC-pDR
 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=H4rxCFlctn44-O6mIyeFf67FlgvznLX7xZqpoWYS41A,25788
-huff-1.5.2.dist-info/METADATA,sha256=XnlmcfscK8c1P3EN40W8JcQnFE7AkWDT4NqLR9skTIY,5956
-huff-1.5.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-huff-1.5.2.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
-huff-1.5.2.dist-info/RECORD,,
+huff-1.5.4.dist-info/METADATA,sha256=Dq-uRGKbKUqNSvB9xUGbox7tRLNB0PDL7QBA_NLfAds,6025
+huff-1.5.4.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+huff-1.5.4.dist-info/top_level.txt,sha256=nlzX-PxZNFmIxANIJMySuIFPihd6qOBkRlhIC28NEsQ,5
+huff-1.5.4.dist-info/RECORD,,