hspf 2.0.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

hspf/hbn.py

@@ -176,6 +176,12 @@ class hbnInterface:
     def get_multiple_timeseries(self,t_opn,t_code,t_con,opnids = None,activity = None,axis = 1):
         return pd.concat([hbn.get_multiple_timeseries(t_opn,t_code,t_con,opnids,activity) for hbn in self.hbns],axis = 1)
 
+    def get_perlnd_constituent(self,constituent,perlnd_ids = None,time_step = 5):
+        return get_simulated_perlnd_constituent(self,constituent,time_step)
+
+    def get_implnd_constituent(self,constituent,implnd_ids = None,time_step = 5):
+        return get_simulated_implnd_constituent(self,constituent,time_step)
+
     def get_reach_constituent(self,constituent,reach_ids,time_step,unit = None):
         if constituent == 'Q':
             df = get_simulated_flow(self,time_step,reach_ids,unit = unit)
@@ -209,48 +215,17 @@ class hbnInterface:
         
         return df
          
-         
+          
     def get_rchres_data(self,constituent,reach_ids,units = 'mg/l',t_code = 'daily'):
         '''
         Convience function for accessing the hbn time series associated with our current
         calibration method. Assumes you are summing across all dataframes.
-
-        Parameters
-        ----------
-        hbn : TYPE
-            DESCRIPTION.
-        nutrient_id : TYPE
-            DESCRIPTION.
-        reach_ids : TYPE
-            DESCRIPTION.
-        flux : TYPE, optional
-            DESCRIPTION. The default is None.
-
-        Returns
-        -------
-        df : TYPE
-            DESCRIPTION.
-
-        '''
-        
-        
+       '''
         
-        t_cons = helpers.get_tcons(constituent,'RCHRES',units)
-        
-
-        
-        df = pd.concat([self.get_multiple_timeseries(t_opn = 'RCHRES',
-                                     t_code =t_code,
-                                     t_con = t_con,
-                                     opnids = reach_ids)
-                         for t_con in t_cons],axis = 1).sum(1).to_frame()
-        
-        if (constituent == 'Q') & (units == 'cfs'):            
-            df = df/CF2CFS[t_code]*43560 #Acrfeet/invl to cubic feet/s
-            
+        df = pd.concat([self.get_reach_constituent(constituent,[reach_id],t_code,units) for reach_id in reach_ids], axis = 1)
+        df.columns = reach_ids
         df.attrs['unit'] = units
         df.attrs['constituent'] = constituent
-        df.attrs['reach_ids'] = reach_ids
         return df
     
         

hspf/hspfModel.py

@@ -30,7 +30,7 @@ class hspfModel():
 
     # Imposed structures of an hspf model:
         # 1. all model files are located in the same directory as the uci file.
-    def __init__(self,uci_file:str):
+    def __init__(self,uci_file:str,run_model:bool = False):
                       #wdm_files:list = None,
                       #hbn_files:str = None):
         # Inputs
@@ -39,7 +39,7 @@ class hspfModel():
         self.wdm_paths = []
         self.uci_file = Path(uci_file).resolve()
         # Validate and load binary data
-        self.validate_uci()
+        self.validate_uci(run_model = run_model)
         
         
         self.hbns = hbn.hbnInterface(self.hbn_paths)
@@ -51,8 +51,28 @@ class hspfModel():
         # Compositions
         self.reports = Reports(self.uci,self.hbns,self.wdms)
         
+
+    def validate_wdms(self):
+        # Ensure wdm files exist and the folders for the other file types exist relative
+        # to the uci path   
+
+        for index, row in self.uci.table('FILES',drop_comments = False).iterrows():
+            file_path = self.uci_file.parent.joinpath(Path(row['FILENAME']))            
+            if file_path.suffix.lower() == '.wdm':
+                assert file_path.exists(),'File Specified in the UCI does not exist:' + file_path.as_posix()
+                self.wdm_paths.append(file_path)
   
-    def validate_uci(self):
+    def validate_pltgens(self):
+        raise NotImplementedError() 
+
+    def validate_folders(self):
+        for index, row in self.uci.table('FILES',drop_comments = False).iterrows():
+            file_path = self.uci_file.parent.joinpath(Path(row['FILENAME']))            
+            assert file_path.parent.exists(),'File folder Specified in the UCI does not exist: ' + file_path.as_posix()
+
+
+ 
+    def validate_uci(self,run_model:bool = False):
         # Ensure wdm files exist and the folders for the other file types exist relative
         # to the uci path   
 
@@ -63,15 +83,15 @@ class hspfModel():
                 self.wdm_paths.append(file_path)
             elif file_path.suffix.lower() == '.hbn':
                 assert file_path.parent.exists(),'File folder Specified in the UCI does not exist: ' + file_path.as_posix()
-                #self.hbns[file_path.name.split('.')[0]] = None
-                if file_path.exists():
-                    #self.hbns[file_path.name.split('.')[0]] = hbn.hbnClass(file_path)
-                    self.hbn_paths.append(file_path)
-                else:
-                    self.run_model()
+                self.hbn_paths.append(file_path)
             else:
                 assert file_path.parent.exists(),'File folder Specified in the UCI does not exist: ' + file_path.as_posix()
 
+        if (all(file_path.exists() for file_path in self.hbn_paths)) & (run_model == False):
+            pass
+        else:
+            self.run_model()
+
     def run_model(self,new_uci_file = None):
         
         if new_uci_file is None:
@@ -80,14 +100,14 @@ class hspfModel():
         # new_uci_file = self.model_path.joinpath(uci_name)
         # self.uci.write(new_uci_file)
         subprocess.run([self.winHSPF,self.uci_file.as_posix()]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
-        self.load_uci(new_uci_file)
+        self.load_uci(new_uci_file,run_model = False)
 
     def load_hbn(self,hbn_name):
         self.hbns[hbn_name] = hbn.hbnClass(self.uci_file.parent.joinpath(hbn_name).as_posix())
 
-    def load_uci(self,uci_file):
+    def load_uci(self,uci_file,run_model:bool = False):
         self.uci = UCI(uci_file)
-        self.validate_uci()
+        self.validate_uci(run_model = run_model)
     
     def convert_wdms(self):
         for wdm_file in self.wdm_paths:

hspf/parser/graph.py

@@ -4,10 +4,12 @@ Created on Thu Feb  6 14:50:45 2025
 
 @author: mfratki
 """
+
 import networkx as nx
 import pandas as pd
 import numpy as np
 import math
+from itertools import chain
 
 class Node(object):
     nodes = []
@@ -17,44 +19,38 @@ class Node(object):
 
     def __str__(self):
         return self._label
-    
-# class PerlndNode(Node):
-#     raise NotImplementedError
-
-# class ReachNode(Node):
-#     raise NotImplementedError
-
-# class ImplndNode(Node):
-#     raise NotImplementedError
+   
 
-# class SourceNode(Node):
-#     raise NotImplementedError
 
-# class TargetNode(Node):
-#     raise NotImplementedError
+# G = nx.MultiDiGraph()
+# reach_nodes = schematic[['TVOL','TVOLNO']].drop_duplicates().reset_index(drop=True).reset_index()
+# nodes = schematic.loc[schematic['SVOL'].isin(['IMPLND','PERLND','GENER'])][['SVOL','SVOLNO']].reset_index(drop=True).reset_index()
 
-# class MetNode(Node):
-#     raise NotImplementedError
 
+# reach_nodes.rename(columns = {'index':'TNODE'},inplace=True)
+# nodes.rename(columns = {'index':'SNODE','TVOL':'OPERATION','TVOLNO':'OPNID'},inplace=True)
+# [G.add_node(row['TNODE'], id = row['TNODE'], category = 'OPERATION', type_id = row['TVOLNO'], type = row['RCHRES'] ) for node,label in reach_nodes.iterrows()] 
 
+# df = pd.merge(schematic,reach_nodes,right_on = ['TVOL','TVOLNO'],left_on = ['TVOL','TVOLNO']).reset_index()
+# df.rename(columns = {'index':'SNODE'},inplace=True)
 
-# class wdmNode(Node):
-#     raise NotImplementedError
 
+# for index, row in df.iterrows():
+#     if row['SVOL'] == 'GENER':
+#         G.add_edge(row['SNODE'],row['TNODE'],
+#                             mlno = row['MLNO'],
+#                             count = row['AFACTR'],
+#                             tmemsb1 = row['TMEMSB1'],
+#                             tmemsb2 = row['TMEMSB2'])
+#     else:
+#         G.add_edge(row['SNODE'],row['TNODE'],
+#                             mlno = row['MLNO'],
+#                             area = row['AFACTR'],
+#                             tmemsb1 = row['TMEMSB1'],
+#                             tmemsb2 = row['TMEMSB2'])
 
-# # Add Parameter Nodes Add edges at same time since it's expensive to determine associated plern/implnd/reach node
-# keys = [key for key in uci.uci.keys() if key[0] in ['IMPLND','RCHRES','PERLND']]
-# for operation,table_name,table_id in keys:  
-#     parms = uci.table(operation,table_name,table_id)
-#     for opnid, row in parms.iterrows():
-#         target_node = graph.get_node(G,operation,opnid)
-#         for parameter in row.index:
-#             G.add_node(max(G.nodes) + 1, type = 'Parameter', value = row[parameter], name = parameter, operation = operation, table_name = table_name, table_id = table_id) 
-#             #labels[(operation,parameter,table_id)] = [max(G.nodes)]  
-#             G.add_edge(max(G.nodes), target_node)
+# G = nx.from_pandas_edgelist(df,'SNODE','TNODE',edge_attr = True,edge_key = 'SNODE', create_using=nx.MultiDiGraph())
 
-    
-    
 def create_graph(uci):
     
     
@@ -82,9 +78,9 @@ def create_graph(uci):
     # Nodes in the schematic block that are missing from the opn sequence block (usually the outlet reach)
     #schematic.loc[schematic.index.map(labels).isna()]
     schematic = schematic.loc[schematic[['snode','tnode']].dropna().index] # For now remove that missing node
-    schematic.loc[:,'TMEMSB1'].replace('',pd.NA,inplace=True)
-    schematic.loc[:,'TMEMSB2'].replace('',pd.NA,inplace=True)
-    schematic.loc[:,'MLNO'].replace('',pd.NA,inplace=True)
+    schematic.loc[:,'TMEMSB1'] = schematic['TMEMSB1'].replace('',pd.NA)
+    schematic.loc[:,'TMEMSB2'] = schematic['TMEMSB2'].replace('',pd.NA)
+    schematic.loc[:,'MLNO'] = schematic['MLNO'].replace('',pd.NA)
 
     schematic = schematic.astype({'snode': int,'tnode':int,'MLNO':pd.Int64Dtype(),'TMEMSB1':pd.Int64Dtype(),'TMEMSB2':pd.Int64Dtype()})
     for index, row in schematic.iterrows():
@@ -101,27 +97,6 @@ def create_graph(uci):
                              tmemsb1 = row['TMEMSB1'],
                              tmemsb2 = row['TMEMSB2'])
         
-    # _ = [G.add_edge(row['snode'],row['tnode'],
-    #                  mlno = row['MLNO'],
-    #                  area = row['AFACTR'],
-    #                  tmemsb1 = row['TMEMSB1'],
-    #                  tmemsb2 = row['TMEMSB2']) for index, row in schematic.iterrows()]
-    
-    
-    
-    #Define edges from Ext Sources
-    # ext_sources['snode'] = ext_sources.index.map(labels)
-    # ext_sources.set_index(['TVOL','TOPFST'],inplace=True)
-    # ext_sources['tnode'] = ext_sources.index.map(labels)
-    # _ = [G.add_edge(row['snode'],row['tnode'],
-    #                  smemn = row['SMEMN'],
-    #                  smemsb = row['SMEMSB'],
-    #                  mfactor = row['MFACTOR'],
-    #                  tran = row['TRAN'],
-    #                  tmemn = row['TMEMN'],
-    #                  tmemsb1 = row['TMEMSB1'],
-    #                  tmemsb2 = row['TMEMSB2']) for index, row in ext_sources.iterrows()]
-    
  
 
     # Add property information
@@ -139,208 +114,10 @@ def create_graph(uci):
         G.nodes[labels[('RCHRES',index)]]['name'] = row['RCHID']
         G.nodes[labels[('RCHRES',index)]]['lkfg'] = row['LKFG']
 
-    
-    # # Add property information
-    # bininfo = uci.table('PERLND','BINARY-INFO')
-    # for index,row in geninfo.iterrows():
-    #     G.nodes[labels[('PERLND',index)]]['name'] = row['LSID']
-        
-    # bininfo = uci.table('IMPLND','BINARY-INFO')
-    # for index,row in geninfo.iterrows():
-    #     G.nodes[labels[('IMPLND',index)]]['name'] = row['LSID']
-        
-    # bininfo = uci.table('RCHRES','BINARY-INFO')
-    # for index,row in geninfo.iterrows():
-    #     G.nodes[labels[('RCHRES',index)]]['name'] = row['RCHID']
-    #     G.nodes[labels[('RCHRES',index)]]['lkfg'] = row['LKFG']
-
-
-    # labels = {}
-    # for n, d in G.nodes(data=True):
-    #     l = (d['operation'],d['opnid'])
-    #     labels[l] = labels.get(l, [])
-    #     labels[l].append(n)
-
-
-
     G.labels = labels
     return G
 
 
-# def create_subgraph(G,start_node):
-#     sub_G = nx.MultDiGraph()
-#     for n in G.successors_iter(start_node):
-#         sub_G.add_path([start_node,n])
-#         create_subgraph(G,sub_G,n)
-
-# Binary info
-
-"""
-CREATE TABLE Operation (
-    opn VARCHAR,
-    opnid INTEGER,
-    PRIMARY KEY (opn, opnid)
-
- 
-    
- )
-
-
-
-
-"""
-
-
-
-
-"""
-CREATE TABLE Files (
-    ftype VARCHAR,
-    unit INTEGER NOT NULL PRIMARY KEY,,
-    filename VARCHAR
-);
-
-"""
-
-
-"""
-CREATE TABLE GenInfo (
-    pk INTEGER NOT NULL,
-    opn VARCHAR,
-    opnid INTEGER,
-    PRIMARY KEY (opn, opnid)
-    iunits INTEGER,
-    ounits INTEGER,
-    punit1 INTEGER,
-    punit2 INTEGER,
-    BUNIT1 INTEGER,
-    BUNIT2 INTEGER
-);
-
-"""
-
-# # Files
-# files = uci.table('FILES')
-# files['FTYPE'] = files['FTYPE'].replace({'WDM': 'WDM1'})
-# dfs = []
-
-# # PerlndInfo
-# operation = 'PERLND'
-# geninfo = uci.table(operation,'GEN-INFO')
-# binaryinfo = uci.table(operation,'BINARY-INFO')
-# if operation == 'RCHRES':
-#     geninfo = geninfo.rename(columns = {'RCHID':'LSID',
-#                                         'BUNITE':'BUNIT1',
-#                                         'BUNITM': 'BUNIT2',
-#                                         'PUNITE': 'PUNIT1',
-#                                         'PUNITM': 'PUNIT2'})
-# df = pd.merge(geninfo,binaryinfo, left_index = True, right_index = True, how = 'outer').reset_index()
-# df.insert(0,'OPN',operation)
-# df = pd.merge(df,files, left_on = 'BUNIT1', right_on = 'UNIT')
-
-# # Schematic Table
-# schematic = uci.table('SCHEMATIC')
-
-# # Masslink Table
-# masslinks = []
-# for table_name in uci.table_names('MASS-LINK'):
-#     mlno = table_name.split('MASS-LINK')[1]
-#     masslink = uci.table('MASS-LINK',table_name)
-#     masslink.insert(0,'MLNO',mlno)
-#     masslinks.append(masslink)
-# masslinks = pd.concat(masslinks)
-
-# #masslinks['QUALID'] = (masslinks['SMEMSB1'].str.strip().replace('','0').astype(int)-1).replace(-1,pd.NA)
-
-
-
-# hbn_name = uci.table('PERLND','QUAL-PROPS', int(row['SMEMSB1']) - 1).iloc[0]['QUALID']
-
-# operation = row['SVOL']
-# activity = row['SGRPN']
-# ts_name = row['SMEMN']
-
-# hbn_name = row['SMEMN'] + hbn_name
-
-
-# schematic = uci.table('SCHEMATIC')
-# schematic = pd.merge(schematic,masslinks,left_on = 'MLNO',right_on = 'MLNO')
-
-# all(schematic['SVOL_x'] == schematic['SVOL_y'])
-# all(schematic['TVOL_x'] == schematic['TVOL_y'])
-# schematic.loc[schematic['TMEMSB1_x'] == '', 'TMEMSB1_y'] = schematic['TMEMSB1_x']
-# schematic.loc[schematic['TMEMSB2_x'] == '', 'TMEMSB2_y'] = schematic['TMEMSB2_x']
-
-# schematic = schematic.drop(columns=['TMEMSB1_y','TMEMSB2_y','TVOL_y','SVOL_y'])
-# schematic = schematic.rename(columns = {'SVOL_x':'SVOL',
-#                               'TVOL_x':'TVOL',
-#                               'TMEMSB2_x':'TMEMSB2',
-#                               'TMEMSB1_x':'TMEMSB1'})
-
-
-
-# # Watershed Weighted Mean 
-# subwatersheds = uci.network.subwatersheds()
-# subwatersheds = subwatersheds.loc[subwatersheds['SVOL'] == 'PERLND'].reset_index()
-# df = cal.model.hbns.get_multiple_timeseries('PERLND',5,'PERO',test['SVOLNO'].values).mean().reset_index()
-# df.columns = ['OPNID','value']
-# weighted_mean = df[['value','AFACTR']].groupby(df['LSID']).apply(lambda x: (x['value'] * x['AFACTR']).sum() / x['AFACTR'].sum())
-# weighted_mean.loc['combined'] =  (df['value'] * df['AFACTR']).sum() / df['AFACTR'].sum()
-
-
-# # annual weighted timeseries watershed
-# reach_ids = [103,119,104,118]
-# subwatersheds = uci.network.subwatersheds().loc[reach_ids]
-# subwatersheds = subwatersheds.loc[subwatersheds['SVOL'] == 'PERLND'].reset_index()
-# df = cal.model.hbns.get_multiple_timeseries('PERLND',5,'PERO',test['SVOLNO'].values).mean().reset_index()
-# df.columns = ['OPNID','value']
-# df = pd.merge(subwatersheds,df,left_on = 'SVOLNO', right_on='OPNID')
-# weighted_mean = (df['value'] * df['AFACTR']).sum() / df['AFACTR'].sum()
-# df[f'weighted_{ts_name}'] = df.groupby('LSID')[parameter].transform(lambda x: (x * df.loc[x.index, 'AFACTR']).sum() / df.loc[x.index, 'AFACTR'].sum())
-# weighted_mean.loc['combined'] =  (df['value'] * df['AFACTR']).sum() / df['AFACTR'].sum()
-
-
-
-# # parameter average weighted by landcover area
-# table_name = 'PWAT-PARM2'
-# parameter = 'LZSN'
-# table_id = 0
-# operation = 'PERLND'
-
-# subwatersheds = uci.network.subwatersheds()
-# subwatersheds = subwatersheds.loc[subwatersheds['SVOL'] == 'PERLND'].reset_index()
-# df = uci.table(operation,table_name,table_id)[parameter].reset_index()
-# df.columns = ['OPNID',parameter]
-# df = pd.merge(subwatersheds,df,left_on = 'SVOLNO', right_on='OPNID')
-# df[f'weighted_{parameter}'] = df.groupby('TVOLNO')[parameter].transform(lambda x: (x * df.loc[x.index, 'AFACTR']).sum() / df.loc[x.index, 'AFACTR'].sum())
-
-
-# #df[f'weighted_{parameter}'] = df.groupby('LSID')[parameter].transform(lambda x: (x * df.loc[x.index, 'AFACTR']).sum() / df.loc[x.index, 'AFACTR'].sum())
-
-
-
-
-# extsources = uci.table('EXT SOURCES')
-# extsources['SVOL'] = extsources['SVOL'].replace({'WDM': 'WDM1'})
-
-# df = pd.merge(extsources,df,left_on = 'SVOL',right_on = 'FTYPE',how = 'right')
-
-
-# exttargets = uci.table('EXT TARGETS')
-# schematic = uci.table('SCHEMATIC')
-
-
-#%% Methods using universal node id
-
-# def bypass_node(G, node):
-#     preds = list(G.predecessors(node))
-#     succs = list(G.successors(node))
-#     for u in preds:
-#         for v in succs:
-#             if 
-#             G.add_edge(u, v)
-#     G.remove_node(node)
-
 def _add_subgraph_labels(G,G_sub):
     G_sub.labels = {label:node for label, node in G.labels.items() if node in G_sub.nodes}
     return G_sub
@@ -424,18 +201,29 @@ def nodes(G,node_type,node_type_id,adjacent_node_type):
 
 #%% Methods using node_type, node_type_id interface
 
-def upstream_network(G,reach_id):
-    return G.subgraph(nx.ancestors(G,get_node_id(G,'RCHRES',reach_id))).copy()
+def upstream_network(G,reach_ids):
+    node_ids = [get_node_id(G,'RCHRES',reach_id) for reach_id in reach_ids]
+        # Initialize an empty set to store all unique ancestors
+    
+    all_ancestors = set()
+    # Iterate through the target nodes and find ancestors for each
+    for node_id in node_ids:
+        ancestors_of_node = nx.ancestors(G, node_id)
+        all_ancestors.update(ancestors_of_node) # Add ancestors to the combined set
+
+    all_ancestors.update(node_ids) # Include the target nodes themselves
+    return G.subgraph(all_ancestors).copy()
+    #return G.subgraph([node_id] + list(nx.ancestors(G,node_id))).copy()
 
 def downstream_network(G,reach_id):
-    return G.subgraph(nx.descendants(G,get_node_id(G,'RCHRES',reach_id))).copy()
+    node_id = get_node_id(G,'RCHRES',reach_id)
+    return G.subgraph([node_id] + list(nx.descendants(G,node_id))).copy()
 
-def subset_network(G,reach_id,upstream_reach_ids = None):
-    G = upstream_network(G,reach_id)
+def subset_network(G,reach_ids,upstream_reach_ids = None):
+    G = upstream_network(G,reach_ids)
     if upstream_reach_ids is not None:
-        [G.remove_nodes_from(nx.ancestors(G,upstream_reach_id)) for upstream_reach_id in upstream_reach_ids if upstream_reach_id in G.nodes]
-        [G.remove_nodes_from([upstream_reach_id]) for upstream_reach_id in upstream_reach_ids if upstream_reach_id in G.nodes]
-    #assert([len(sinks(G)) == 0,sinks(G)[0] == reach_id])
+        G.remove_nodes_from(get_node_ids(upstream_network(G,upstream_reach_ids),'RCHRES'))
+        #assert([len(sinks(G)) == 0,sinks(G)[0] == reach_id])
     return G
 
 def upstream_nodes(G,reach_id,upstream_node_type):
@@ -512,8 +300,8 @@ def routing_reachs(G):
 def is_routing(G,reach_id):
     return all([node['type'] not in ['PERLND', 'IMPLND'] for node in adjacent_nodes(G,reach_id)])
 
-def watershed_area(G,reach_ids):
-    return float(np.nansum(list(nx.get_edge_attributes(make_watershed(G,reach_ids),'area').values())))
+def watershed_area(G,reach_ids,upstream_reach_ids = None):
+    return float(np.nansum(list(nx.get_edge_attributes(make_watershed(G,reach_ids,upstream_reach_ids),'area').values())))
 
 def catchment_area(G,reach_id):
     return float(np.nansum(list(nx.get_edge_attributes(make_catchment(G,reach_id),'area').values())))
@@ -553,22 +341,47 @@ def make_catchment(G,reach_id):
     nx.set_node_attributes(catchment,node_id,'catchment_id')
     return catchment
 
-from itertools import chain
-
-def make_watershed(G,reach_ids):
+def make_watershed(G,reach_ids,upstream_reach_ids = None):
     '''
     Creates a sugraph representing the the catchments upstream of the specified hspf model reaches. Note that a negative reach_ids indicate to subtract that area from the total.
     
     
     ''' 
-    node_ids = set([get_node_id(G,'RCHRES',reach_id) for reach_id in reach_ids if reach_id > 0])
-    nodes_to_exclude = set([get_node_id(G,'RCHRES',abs(reach_id)) for reach_id in reach_ids if reach_id < 0])
-    node_ids = node_ids - nodes_to_exclude
+
+    node_ids = set(get_node_id(G,'RCHRES',reach_id) for reach_id in reach_ids)
+
+    # Initialize an empty set to store all unique ancestors
     
+    # Iterate through the target nodes and find ancestors for each
+    all_upstream_reaches = set()
+    for node_id in node_ids:
+        ancestors_of_node = [node['id'] for node in ancestors(G, node_id,'RCHRES')]
+        all_upstream_reaches.update(ancestors_of_node) # Add ancestors to the combined set
+    all_upstream_reaches.update(node_ids) # Include the target nodes themselves
+
+    if upstream_reach_ids is not None:
+        upstream_node_ids = set(get_node_id(G,'RCHRES',reach_id) for reach_id in upstream_reach_ids)
+        for node_id in upstream_node_ids:
+            ancestors_of_node = [node['id'] for node in ancestors(G, node_id,'RCHRES')]
+            all_upstream_reaches = all_upstream_reaches - set(ancestors_of_node)
+    else:
+        upstream_node_ids = set()
+
+    nodes = set(chain.from_iterable([list(G.predecessors(node_id)) for node_id in all_upstream_reaches])) | node_ids
+    nodes = nodes - upstream_node_ids # Include the target nodes themselves
+
+
+    return G.subgraph(nodes).copy()
+    
+    
+    # node_ids = set([get_node_id(G,'RCHRES',reach_id) for reach_id in reach_ids if reach_id > 0])
+    # nodes_to_exclude = set([get_node_id(G,'RCHRES',abs(reach_id)) for reach_id in reach_ids if reach_id < 0])
+    # node_ids = node_ids - nodes_to_exclude
     
-    nodes = [list(nx.ancestors(G,node_id)) for node_id in node_ids]
-    nodes.append(node_ids)
-    nodes = list(set(chain.from_iterable(nodes)))
+    #nodes = get_opnids(G,'RCHRES',reach_ids,upstream_reach_ids) #[ancestors(G,node_id,'RCHRES')) for node_id in node_ids]
+    nodes = subset_network(G,reach_ids,upstream_reach_ids)
+    #nodes.append(node_ids)
+    #nodes = list(set(chain.from_iterable(nodes)))
     watershed = subgraph(G, nodes)
     catchment_id = '_'.join([str(reach_id) for reach_id in reach_ids])
     nx.set_node_attributes(watershed,node_ids,catchment_id)
@@ -654,8 +467,17 @@ class Catchment():
     def dsn(self,tmemn):
         return [self.catchment.nodes[k[0]]['id']  for k,v in nx.get_edge_attributes(self.catchment,'tmemn').items() if v == tmemn]
     
-    def to_dataframe():
-        return 
+    def to_dataframe(self):
+        edges = []
+        for u, v, edge_data in self.catchment.edges(data=True):
+            source_node_attributes = self.catchment.nodes[u]
+            # Add or update edge attributes with source node attributes
+            edge_data["source_type"] = source_node_attributes.get("type")
+            edge_data["source_name"] = source_node_attributes.get("name")
+            edge_data["source_type_id"] = source_node_attributes.get("type_id")
+            edges.append(edge_data)
+        
+        return pd.DataFrame(edges)
 # def _watershed(G,reach_id):
     
 #     predecessors = (list(G.predecessors(node)))
@@ -676,7 +498,17 @@ class Catchment():
     
 #     {source:[node for node in nx.shortest_path(G,source,reach_id)] for source in nx.ancestors(G,reach_id)}
 
-
+def to_dataframe(G):
+    edges = []
+    for u, v, edge_data in G.edges(data=True):
+        source_node_attributes = G.nodes[u]
+        # Add or update edge attributes with source node attributes
+        edge_data["source_type"] = source_node_attributes.get("type")
+        edge_data["source_name"] = source_node_attributes.get("name")
+        edge_data["source_type_id"] = source_node_attributes.get("type_id")
+        edges.append(edge_data)
+    
+    return pd.DataFrame(edges)
 
 
 #%% Legacy Methods for Backwards compatability
@@ -710,8 +542,16 @@ class reachNetwork():
         downstream.insert(0,reach_id)
         return downstream
         
-    def calibration_order(self,reach_id,upstream_reach_ids = None):
-        return calibration_order(self.G,reach_id,upstream_reach_ids)
+    def calibration_order(self,reach_ids,upstream_reach_ids = None):
+        '''
+        Calibration order of reaches to prevent upstream influences. Equivalent to iteritivlye pruning the network remving nodes with no upstream connections.
+        A list of lists is returned where each sublist contains reaches that can be calibrated in parallel.
+        
+        :param self: Description
+        :param reach_ids: Description
+        :param upstream_reach_ids: Description
+        '''
+        return calibration_order(make_watershed(self.G,reach_ids,upstream_reach_ids))
     
     def station_order(self,reach_ids):
         raise NotImplementedError()
@@ -731,30 +571,30 @@ class reachNetwork():
         '''
         return  [node['type_id'] for node in predecessors(self.G,'RCHRES',get_node_id(self.G,'RCHRES',reach_id))]
         
-    def get_opnids(self,operation,reach_id, upstream_reach_ids = None):
+    def get_opnids(self,operation,reach_ids, upstream_reach_ids = None):
         '''
         Operation IDs with a path to reach_id. Operations upstream of upstream_reach_ids will not be included
 
         '''
-        return get_opnids(self.G,operation=operation,reach_id = reach_id, upstream_reach_ids = upstream_reach_ids)
-    
+        return get_opnids(self.G,operation,reach_ids,upstream_reach_ids)    
     def operation_area(self,operation,opnids = None):
+        '''
+        Area of operation type for specified operation IDs. If None returns all operation areas.
+        Equivalent to the schematic table filtered by operation and opnids.
+        '''
+
         return operation_area(self.uci,operation)  
         
     def drainage(self,reach_id):
-        # Merge source node attributes into edge attributes
-    
-        edges = []
-        for u, v, edge_data in make_catchment(self.G,reach_id).edges(data=True):
-            source_node_attributes = self.G.nodes[u]
-            # Add or update edge attributes with source node attributes
-            edge_data["source_type"] = source_node_attributes.get("type")
-            edge_data["source_name"] = source_node_attributes.get("name")
-            edge_data["source_type_id"] = source_node_attributes.get("type_id")
-            edges.append(edge_data)
+        '''
+        Docstring for drainage
         
-        return pd.DataFrame(edges)
-    
+        :param self: Network class instance
+        :param reach_id: Target reach id 
+        '''
+        # Merge source node attributes into edge attributes
+        return to_dataframe(make_catchment(self.G,reach_id))
+
     def subwatersheds(self,reach_ids = None):
         df = subwatersheds(self.uci)
         if reach_ids is None:
@@ -773,15 +613,16 @@ class reachNetwork():
     def reach_contributions(self,operation,opnids):
         return reach_contributions(self.uci,operation,opnids)
     
-    def drainage_area(self,reach_ids):
-        return watershed_area(self.G,reach_ids)
+    def drainage_area(self,reach_ids,upstream_reach_ids = None):
+        return watershed_area(self.G,reach_ids,upstream_reach_ids)
     
-    def drainage_area_landcover(self,reach_id,group = True):
-        reach_ids = self._upstream(reach_id)
-        areas = pd.concat([self.subwatershed(reach_id) for reach_id in reach_ids]).groupby(['SVOL','SVOLNO'])['AFACTR'].sum()
-        
-        if group:    
-            areas = pd.concat([areas[operation].groupby(self.uci.opnid_dict[operation].loc[areas[operation].index,'LSID'].values).sum() for operation in ['PERLND','IMPLND']])
+    def drainage_area_landcover(self,reach_ids,upstream_reach_ids = None, group = True):
+        areas = to_dataframe(make_watershed(self.G,reach_ids,upstream_reach_ids))
+        areas = areas.groupby(['source_type','source_type_id','source_name'])['area'].sum()[['PERLND','IMPLND']]
+
+        if group:  
+            areas = pd.concat([areas[operation].groupby('source_name').sum()  for operation in ['PERLND','IMPLND']])
+            #areas = pd.concat([areas[operation].groupby(self.uci.opnid_dict[operation].loc[areas[operation].index,'LSID'].values).sum() for operation in ['PERLND','IMPLND']])
         return areas
 
     def outlets(self):
@@ -799,48 +640,28 @@ class reachNetwork():
     def paths(self,reach_id):
         return paths(self.G,reach_id)
     
-    
-def calibration_order(G,reach_id,upstream_reach_ids = None):
+
+def get_opnids(G,operation,reach_ids, upstream_reach_ids = None):
+    return get_node_type_ids(make_watershed(G,reach_ids,upstream_reach_ids),operation)
+
+
+def calibration_order(G):
     '''
-    Determines the order in which the specified reaches should be calibrated to
+    Determines the order in which the model reaches should be calibrated to
     prevent upstream influences. Primarily helpful when calibrating sediment and
     adjusting in channel erosion rates.
     '''
     
+    nodes = get_node_ids(G,'RCHRES')
+    G = G.subgraph(nodes).copy()
     order = []
-    Gsub = subgraph(G,get_node_ids(G,'RCHRES'))
-    while(len(Gsub.nodes)) > 0:
-   
-        nodes_to_remove = [node for node, in_degree in Gsub.in_degree() if in_degree == 0]
+    while(len(nodes)) > 0:
+        nodes_to_remove = [node for node in nodes if G.in_degree(node) == 0]
         order.append([G.nodes[node]['type_id'] for node in nodes_to_remove])
-        Gsub.remove_nodes_from(nodes_to_remove)         
+        nodes = [node for node in nodes if node not in nodes_to_remove]
+        G.remove_nodes_from(nodes_to_remove)
     return order
-    
-
-
-
-def get_opnids(G,operation,reach_id = None, upstream_reach_ids = None):
-    G = subset_network(G,reach_id,upstream_reach_ids)
-    perlnds = [node['type_id'] for node in get_nodes(G,'PERLND')]
-    implnds = [node['type_id'] for node in get_nodes(G,'IMPLND')]
-    reachs = [node['type_id'] for node in get_nodes(G,'RCHRES')]
-    return {'RCHRES':reachs,'PERLND':perlnds,'IMPLND':implnds}[operation]
-    #return reachs,perlnds,implnds
-
-def drainage(uci,reach_ids):
-    return subwatersheds(uci).loc[reach_ids].reset_index()[['SVOL','LSID','AFACTR']].groupby(['LSID','SVOL']).sum()
-
-
-
-def drainage_area(uci,reach_ids,drng_area = 0):
-    if len(reach_ids) == 0:
-        return drng_area
-    else:
-        sign = math.copysign(1,reach_ids[0])
-        reach_id = int(reach_ids[0]*sign)
-        drng_area = drng_area + sign*uci.network.drainage_area(reach_id)
-        drainage_area(uci,reach_ids[1:],drng_area)
-                
+       
 
 def reach_contributions(uci,operation,opnids):
     schematic = uci.table('SCHEMATIC').set_index('SVOL')

hspf/parser/parsers.py

@@ -6,6 +6,7 @@ Created on Fri Oct  7 12:13:23 2022
 """
 
 from abc import abstractmethod
+from multiprocessing.util import info
 import numpy as np
 import pandas as pd
 from pathlib import Path
@@ -52,7 +53,10 @@ class Table():
     
         self.parser = parserSelector[self.block]
         #self.updater = Updater
-        
+    
+    def _delimiters(self):
+        return delimiters(self.block,self.name)
+    
     def parse(self):
         self.data = self.parser.parse(self.block,self.name,self.lines)
         
@@ -286,7 +290,29 @@ class masslinkParser(Parser):
                 table_lines[index] = line[-1]
                 
         return table_lines       
-  
+
+class globalParser(Parser):
+    def parse(block,table_name,table_lines):
+        table_lines = [line for line in table_lines if '***' not in line]
+        data = {
+            'description' : table_lines[0].strip(),
+            'start_date' : table_lines[1].split('END')[0].split()[1],
+            'start_hour' :  int(table_lines[1].split('END')[0].split()[2][:2])-1,
+            'end_date' : table_lines[1].strip().split('END')[1].split()[0],
+            'end_hour' : int(table_lines[1].strip().split('END')[1].split()[1][:2])-1,
+            'echo_flag1' : int(table_lines[2].split()[-2]),
+            'echo_flag2' : int(table_lines[3].split()[-1]),
+            'units_flag' : int(table_lines[3].split()[5]),
+            'resume_flag': int(table_lines[3].split()[1]),
+            'run_flag': int(table_lines[3].split()[3]) 
+        }
+        df = pd.DataFrame([data])
+        df['comments'] = ''
+        return df
+    
+    def write(block,table_name,table):
+        raise NotImplementedError()
+
 class specactionsParser(Parser):
     def parse(block,table,lines):
         raise NotImplementedError()
@@ -301,7 +327,7 @@ class externalsourcesParser():
     def write(block,table,lines):
         raise NotImplementedError()
 
-parserSelector = {'GLOBAL':defaultParser,
+parserSelector = {'GLOBAL':globalParser,
                 'FILES':standardParser,
                 'OPN SEQUENCE':opnsequenceParser,
                 'PERLND':operationsParser,

hspf/reports.py

@@ -325,6 +325,7 @@ def ann_avg_subwatershed_loading(constituent,uci,hbn):
     return df
 
 def ann_avg_watershed_loading(constituent,reach_ids,uci,hbn, by_landcover = False):
+    reach_ids = [item for sublist in [uci.network._upstream(reach_id) for reach_id in reach_ids] for item in sublist]
     df = ann_avg_constituent_loading(constituent,uci,hbn)
     df = df.loc[df['TVOLNO'].isin(reach_ids)]
     if by_landcover:

hspf/uci.py

@@ -8,6 +8,7 @@ Created on Mon Jul 11 08:39:57 2022
 
 #lines = reader('C:/Users/mfratki/Documents/Projects/LacQuiParle/ucis/LacQuiParle_0.uci')
 import subprocess
+import sys
 import numpy as np
 import pandas as pd
 from .parser.parsers import Table
@@ -78,7 +79,7 @@ class UCI():
                  
     def table(self,block,table_name = 'na',table_id = 0,drop_comments = True):
         # Dynamic parsing of tables when called by user
-        assert block in ['FILES','PERLND','IMPLND','RCHRES','SCHEMATIC','OPN SEQUENCE','MASS-LINK','EXT SOURCES','NETWORK','GENER','MONTH-DATA','EXT TARGETS','COPY','FTABLES']
+        assert block in ['GLOBAL','FILES','PERLND','IMPLND','RCHRES','SCHEMATIC','OPN SEQUENCE','MASS-LINK','EXT SOURCES','NETWORK','GENER','MONTH-DATA','EXT TARGETS','COPY','FTABLES']
         
         table = self.uci[(block,table_name,table_id)] #[block][table_name][table_id]
         #TODO move the format_opnids into the Table class?
@@ -103,7 +104,7 @@ class UCI():
         self.uci[(block,table_name,table_id)].replace(table)
 
     def table_lines(self,block,table_name = 'na',table_id = 0):
-        return self.uci[(block,table_name,table_id)].lines
+        return self.uci[(block,table_name,table_id)].lines.copy()
         
     def comments(block,table_name = None,table_id = 0): # comments of a table
         raise NotImplementedError()
@@ -176,13 +177,80 @@ class UCI():
             lines += ['']
         lines += ['END RUN']
         self.lines = lines       
+
+    def set_simulation_period(self,start_year,end_year):
+        # Update GLOBAL table with new start and end dates very janky implementation but not a priority.
+
+        # if start_hour < 10:
+        #     start_hour = f'0{int(start_hour+1)}:00'
+        # else:
+        #     start_hour = f'{int(start_hour+1)}:00'
         
-    
+        # if end_hour < 10:
+        #     end_hour = f'0{int(end_hour+1)}:00'
+        # else:
+        #     end_hour = f'{int(end_hour+1)}:00'
+
+        table_lines = self.table_lines('GLOBAL')  
+        for index, line in enumerate(table_lines):
+            if '***' in line: #in case there are comments in the global block
+                continue
+            elif line.strip().startswith('START'):
+                table_lines[index] = line[0:14] + f'{start_year}/01/01 00:00  ' + f'END    {end_year}/12/31 24:00'
+            else:
+                continue
+
+        self.uci[('GLOBAL','na',0)].lines = table_lines
+
+    def set_echo_flags(self,flag1,flag2):
+        table_lines = self.table_lines('GLOBAL')  
+        for index, line in enumerate(table_lines):
+            if '***' in line: #in case there are comments in the global block
+                continue
+            elif line.strip().startswith('RUN INTERP OUTPT LEVELS'):
+                table_lines[index] = f'  RUN INTERP OUTPT LEVELS    {flag1}    {flag2}'
+            else:
+                continue
+        
+
+        self.uci[('GLOBAL','na',0)].lines = table_lines
+
+
+    def _write(self,filepath):
+        with open(filepath, 'w') as the_file:
+            for line in self.lines:    
+                the_file.write(line+'\n')
+
+    def add_parameter_template(self,block,table_name,table_id,parameter,tpl_char = '~'):
+        
+        table = self.table(block,table_name,0,False).reset_index()
+        column_names,dtypes,starts,stops = self.uci[(block,table_name,table_id)]._delimiters()
+        
+        width = stops[column_names.index(parameter)] - starts[column_names.index(parameter)]
+
+        ids = ~table[parameter].isna() # Handle comment lines in uci
+
+        # Replace paramter name with PEST/PEST++ specification. Note this does not use the HSPF supplemental file so parameters are limited to width of uci file column
+        pest_param = tpl_char + parameter.lower() +  table.loc[ids,'OPNID'].astype(str)
+        pest_param = pest_param.apply(lambda name: name + ' '*(width-len(name)-1)+ tpl_char)
+
+        table.loc[ids,parameter] = pest_param
+        table = table.set_index('OPNID')
+        self.replace_table(table,block,table_name,table_id)
+
+    def write_tpl(self,tpl_char = '~',new_tpl_path = None):    
+        if new_tpl_path is None:
+            new_tpl_path = self.filepath.parent.joinpath(self.filepath.stem + '.tpl')
+        self.merge_lines()
+        self.lines.insert(0,tpl_char)
+        self._write(new_tpl_path)
+
     def write(self,new_uci_path):
         self.merge_lines()
-        with open(new_uci_path, 'w') as the_file:
-            for line in self.lines:    
-                the_file.write(line+'\n')   
+        self._write(new_uci_path) 
+
+    def _run(self,wait_for_completion=True):
+        run_model(self.filepath, wait_for_completion=wait_for_completion)
 
     def update_bino(self,name):
         #TODO: Move up to busniess/presentation layer
@@ -298,9 +366,25 @@ class UCI():
 
 #TODO: More conveince methods that should probably be in a separate module
 
-def run_model(uci_file):
-    winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
-    subprocess.run([winHSPF,uci_file.as_posix()]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
+def run_model(uci_file, wait_for_completion=True):
+    winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFlt\\WinHspfLt.exe'
+    
+    # Arguments for the subprocess
+    args = [winHSPF, uci_file.as_posix()]
+
+    if wait_for_completion:
+        # Use subprocess.run to wait for the process to complete (original behavior)
+        subprocess.run(args)
+    else:
+        # Use subprocess.Popen to run the process in the background without waiting
+        # On Windows, you can use creationflags to prevent a console window from appearing
+        if sys.platform.startswith('win'):
+            # Use a variable for the flag to ensure it's only used on Windows
+            creationflags = subprocess.CREATE_NO_WINDOW
+            subprocess.Popen(args, creationflags=creationflags)
+        else:
+            # For other platforms (like Linux/macOS), Popen without special flags works fine
+            subprocess.Popen(args)
 
 def get_filepaths(uci,file_extension):
     files = uci.table('FILES')

{hspf-2.0.2.dist-info → hspf-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hspf
-Version: 2.0.2
+Version: 2.1.0
 Summary: Python package for downloading and running HSPF models
 Project-URL: Homepage, https://github.com/mfratkin1/pyHSPF
 Author-email: Mulu Fratkin <michael.fratkin@state.mn.us>

{hspf-2.0.2.dist-info → hspf-2.1.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
 hspf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hspf/hbn.py,sha256=SQMxWllZy5OxWGMkhmjiardb8vbSjrmENJrorLBqTDI,19476
+hspf/hbn.py,sha256=X-xFTrJ9Z7rM_spMaZxyUIXisUKEm36Gq0gCG-mYuSY,18982
 hspf/helpers.py,sha256=djKc12ZZkJmB_cHEbFm-mk8sp4GAbBNfjXxfp7YAELU,3132
-hspf/hspfModel.py,sha256=8XFPd89niSn9bNTjB2UUpoLNAs6wsD6i6Lb9YKoYjUU,8090
-hspf/reports.py,sha256=DfS9DoNwrnD3UvxO879i-bM2gWh5QUMxrV4mdRDgpfE,51878
-hspf/uci.py,sha256=kb05yc_pmO7w8e8tDOxD7Ln0PxhYALmU8yeoQZHRw9g,30323
+hspf/hspfModel.py,sha256=K_xF7HtuMpDMod56Z3IXDCeGsnUi8KGhly_9tm-mxoY,9070
+hspf/reports.py,sha256=ALAeGP0KYdsFUnzAV5BZ784NRDxKgn42GKZpyq3E4xU,51997
+hspf/uci.py,sha256=rsi_KJqdfBFp0rlKCHyhmQGdB_rgNE8k6abTjH26UqE,33982
 hspf/wdm.py,sha256=q0hNqsMNrTkxHtKEX0q0wWlIZabXv6UX2HjNCF9WEW4,12734
 hspf/wdmReader.py,sha256=-akKWB9SpUzXvXoQMeHLZNi_u584KaeEOyHB-YolTWM,22848
+hspf/bin/WinHSPFLt/WinHspfLt.exe,sha256=Afs_nJ62r1VnTL2P4XfiRJ1sH2If5DeGTbcCzoqlanE,74752
 hspf/data/ParseTable.csv,sha256=ExqUaZg_uUPF5XHGLJEk5_jadnDenKjbwqC4d-iNX_M,193609
 hspf/data/Timeseries Catalog/IMPLND/IQUAL.txt,sha256=r36wt2gYtHKr5SkOcVnpyk5aYZF743AgkJ5o7CvHlIc,1000
 hspf/data/Timeseries Catalog/IMPLND/IWATER.txt,sha256=JZ03DFMq8e3EcflRSQ_BPYIeKe8TH3WYEUMmTF2OQEs,743
@@ -27,8 +28,8 @@ hspf/data/Timeseries Catalog/RCHRES/OXRX.txt,sha256=NWdRFpJ60LsYzCGHjt8Llay3OI8j
 hspf/data/Timeseries Catalog/RCHRES/PLANK.txt,sha256=0MAehIrF8leYQt0Po-9h6IiujzoWOlw-ADCV-bPiqs0,3508
 hspf/data/Timeseries Catalog/RCHRES/SEDTRN.txt,sha256=SiTgD4_YWctTgEfhoMymZfv8ay74xzCRdnI005dXjyE,659
 hspf/parser/__init__.py,sha256=2HvprGVCaJ9L-egvTj1MI-bekq5CNjtSBZfrCtQi3fs,92
-hspf/parser/graph.py,sha256=zjIhr-6y8Iy4jJM-V__aP7Q3zkRzr8PajuHjgqy3cBk,37085
-hspf/parser/parsers.py,sha256=Uk7RD_9aAX4TTjUOyPfwdURPdmE2M2_YItny2PedGi4,19717
-hspf-2.0.2.dist-info/METADATA,sha256=EOwcX8KhToElTZ44rqHbD7mD53d7Nx33ttyHcyZckQc,605
-hspf-2.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hspf-2.0.2.dist-info/RECORD,,
+hspf/parser/graph.py,sha256=AQkimUP232P3STLFVN2sfrpwiEdGvcc-244TQb8RIgs,32595
+hspf/parser/parsers.py,sha256=x3othxQogUmGNe_ctCU20atDrRM_B4lEbVJb3EMbwto,20850
+hspf-2.1.0.dist-info/METADATA,sha256=SHh9Lng8KdpN2vjaFZe5dFeFI5RsxypQEIrhGlu8G6s,605
+hspf-2.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hspf-2.1.0.dist-info/RECORD,,

{hspf-2.0.2.dist-info → hspf-2.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any