pyhcal 1.0.2__tar.gz → 1.1.1__tar.gz

pyhcal-1.1.1/ERROR.FIL

@@ -0,0 +1,6 @@
+11:01:39.908 : LOG_MSG:ERROR.FIL OPENED
+11:01:39.909 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+11:01:39.910 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0

{pyhcal-1.0.2 → pyhcal-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyhcal
-Version: 1.0.2
+Version: 1.1.1
 Summary: Python package for calibrating MPCA HSPF models
 Project-URL: Homepage, https://github.com/mfratkin1/pyhcal
 Author-email: Mulu Fratkin <michael.fratkin@state.mn.us>

{pyhcal-1.0.2 → pyhcal-1.1.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "pyhcal"
 urls = { "Homepage" = "https://github.com/mfratkin1/pyhcal" }  # ? Add this!
-version = "1.0.2"
+version = "1.1.1"
 dependencies = [
   "hspf",
   "mpcaHydro",

pyhcal-1.1.1/src/pyhcal/ERROR.FIL

@@ -0,0 +1,78 @@
+16:15:00.416 : LOG_MSG:ERROR.FIL OPENED
+16:15:00.417 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+16:15:00.417 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:06:13.144 : LOG_MSG:ERROR.FIL OPENED
+18:06:13.145 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:06:13.145 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:09:53.704 : LOG_MSG:ERROR.FIL OPENED
+18:09:53.705 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:09:53.705 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:19:02.896 : LOG_MSG:ERROR.FIL OPENED
+18:19:02.896 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:19:02.896 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:19:05.790 : LOG_MSG:ERROR.FIL OPENED
+18:19:05.790 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:19:05.790 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:32:46.775 : LOG_MSG:ERROR.FIL OPENED
+18:32:46.776 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:32:46.776 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:38:43.431 : LOG_MSG:ERROR.FIL OPENED
+18:38:43.432 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:38:43.432 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:44:23.798 : LOG_MSG:ERROR.FIL OPENED
+18:44:23.799 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:44:23.800 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:52:12.607 : LOG_MSG:ERROR.FIL OPENED
+18:52:12.608 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:52:12.608 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+18:59:18.608 : LOG_MSG:ERROR.FIL OPENED
+18:59:18.609 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+18:59:18.609 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+19:05:51.046 : LOG_MSG:ERROR.FIL OPENED
+19:05:51.047 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+19:05:51.047 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+19:14:05.088 : LOG_MSG:ERROR.FIL OPENED
+19:14:05.088 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+19:14:05.089 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0
+19:18:33.712 : LOG_MSG:ERROR.FIL OPENED
+19:18:33.713 : HASS_ENT:F90_WDBOPNR:entr:WDMSFL,RWFLG:         100           1 C:\Users\mfratki\Documents\github\pyHSPF\src\hspf\bin\WinHSPFLt\hspfmsg.wdm
+19:18:33.713 : HASS_ENT:F90_WDBOPNR:exit:WDMSFL,RETCOD         100           0
+FILBLK RETCOD           0
+wdmfl           0           0           0           0
+FILBLK RETCOD           0

{pyhcal-1.0.2 → pyhcal-1.1.1}/src/pyhcal/calibrators.py

@@ -9,11 +9,8 @@ from copy import deepcopy
 import subprocess
 #non-standard imports
 import pandas as pd
-pd.set_option('display.max_columns', None)
-pd.set_option('display.max_rows', None)
-# to reset this
-pd.reset_option('display.max_columns')
 import numpy as np
+import geopandas as gpd
 from pathlib import Path
 
 #My packages
@@ -23,62 +20,39 @@ from hspf import helpers
 from mpcaHydro import data_manager as dm
 from pyhcal import metrics
 from pyhcal import figures
-from pyhcal.setup_utils import Builder
-#from hspf_tools.orm.monitoring_db import MonitoringDatabase
+from pyhcal import setup_utils
+from pyhcal.mappers import Mapper
 
+def new_calibration(project_folder,model_name,download_station_data = True,run_model = True,convert_wdms = True):
+    return setup_utils.create_calibration_project(model_name,project_folder,download_station_data,run_model,convert_wdms)
 
-class calProject():
-    #valid_models = Builder.valid_models()
-    def __init__(self,project_location):
-        self.project_location = Path(project_location)
-        
-    
-    def new_project(self,model_name):
-        return Builder(model_name) #self._builder.new_project(project_location,model_name)
-    
-    def load_project(self,model_name):
-        if model_name in [f.name for f in self.project_location.iterdir() if f.is_dir()]:
-            return calibrator(self.project_location.joinpath(model_name))
-        else:
-            answer = input("No calibration project for that model. Would you like to set on up? (yes or no")
-            if answer.lower() in ["y","yes"]:
-                self.new_project(model_name)
-                return calibrator(self.project_location.joinpath(model_name))
-            elif answer.lower() in ["n","no"]:
-                return
-                # Do other stuff
-            else:
-                print('please enter yes or no')
-            
-    
-def config_info(project_folder):
-    project_path = Path(project_folder)
-    info = {'project_path'  : project_path,
-             'project_name' : project_path.name,
-             'model_path'   : project_path.joinpath('model'),
-             'output_path'  : project_path.joinpath('output'),
-             'start_date'   : '1996-01-01',
-             'end_date'     : '2100-01-01',
-            }     
-    return info
 
+def load(project_folder):
+    validate_project_folder(project_folder)
+    return calibrator(project_folder)
 
-
-        
+def validate_project_folder(project_folder):
+    project_path = Path(project_folder)
+    assert project_path.exists(), 'Project folder does not exist'
+    assert project_path.joinpath('model').exists(), 'Model folder does not exist'
+    assert project_path.joinpath('data').exists(), 'Data folder does not exist'
+    assert project_path.joinpath('output').exists(), 'Output folder does not exist'
+    assert project_path.joinpath('targets.csv').exists(), 'targets.csv file does not exist in project folder'
+    return True
+ 
 class calibrator:
     def __init__(self,project_folder):
         self.project_path = Path(project_folder)
         self.project_name = self.project_path.name
         self.model_path = self.project_path.joinpath('model')
         self.output_path = self.project_path.joinpath('output')
+        self.gis_path = self.project_path.joinpath('gis')
         self.run = None
-        #self.winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
         self.start_date = '1996-01-01'
         self.end_date = '2100-01-01'
         
         # Load observational data into memory TODO: Convert to database?
         self.dm = dm.dataManager(self.project_path.joinpath('data'))
-        #self.odm = MonitoringDatabase(cal.project_path.joinpath(cal.project_name))
      
         self.targets = None
         if self.project_path.joinpath('targets.csv').exists():
@@ -86,25 +60,48 @@ class calibrator:
               
         self.MODL_DB = pd.read_csv(self.project_path.joinpath('_'.join([self.project_name ,'MODL_DB.csv'])))
         
+        # Alot of effort to try and include the subwatershed gdf if it exists. TODO: refactor
+        self.subwatershed_gdf_filepath = self.gis_path.joinpath('_'.join([self.project_name ,'Subwatersheds.shp']))
+        if self.subwatershed_gdf_filepath.exists():
+            self.subwatershed_gdf = gpd.read_file(self.subwatershed_gdf_filepath)
+            if 'SubID' in self.subwatershed_gdf.columns:
+                self.subwatershed_gdf = self.subwatershed_gdf.set_index('SubID')
+            else:
+                print("Warning: 'SubID' column not found in subwatershed shapefile. GIS operations will not function correctly.")
+        else:
+            self.subwatershed_gdf = None
+        
         self.model = None
         self._wdms = None
         self.uci = None
-        
+        self.mapper = None
     ## Input/Output methods
+
+
     def initialize(self,reach_ids,default = 4):
 
         self.uci.update_table(default,'RCHRES','BINARY-INFO',0,columns = ['HEATPR','HYDRPR','SEDPR','OXRXPR','NUTRPR','PLNKPR'],operator = 'set')
         self.uci.update_table(2,'RCHRES','BINARY-INFO',0,columns = ['HEATPR','HYDRPR','SEDPR','OXRXPR','NUTRPR','PLNKPR'],opnids = reach_ids,operator = 'set')
         
         self.uci.write(self.model.uci_file)
-        winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
-        subprocess.run([winHSPF,self.model.uci_file]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
+        subprocess.run([self.model.winHSPF,self.model.uci_file]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
         
     def set_dates(self, start_date = '1996-01-01',end_date ='2100-01-01'):
         self.start_date = start_date
         self.end_date = end_date
 
-        
+    def _load_gdf(self,catchment_id_column = 'SubID'):
+        self.subwatershed_gdf_filepath = self.gis_path.joinpath('_'.join([self.project_name ,'Subwatersheds.shp']))
+        if self.subwatershed_gdf_filepath.exists():
+            self.subwatershed_gdf = gpd.read_file(self.subwatershed_gdf_filepath)
+            self.subwatershed_gdf = self.subwatershed_gdf.set_index(catchment_id_column)
+        else:
+            self.subwatershed_gdf = None
+
+    def _update_mapper(self):
+        if self.subwatershed_gdf is not None:
+            self.mapper = Mapper(self.project_name,self.uci,self.subwatershed_gdf,hbn = self.model.hbns)
+
     def load_model(self,name):
 
         if isinstance(name,int): # Default approach
@@ -126,12 +123,11 @@ class calibrator:
                 
         self.model.wdms = self._wdms
         self.model.reports.wdms = self._wdms
-        self.uci = deepcopy(self.model.uci) #uci to be manipulated 
+        self.uci = deepcopy(self.model.uci) #uci to be manipulated
+
+        if self.subwatershed_gdf is not None:
+            self.mapper = Mapper(self.project_name,self.uci,self.subwatershed_gdf,hbn = self.model.hbns)
 
-        
-    # def setup_run(self, reach_ids = None, time_Step = 3,n = 1):
-    #     setup_utils.setup(self.uci,self.project_name,run = self.run,reach_ids = reach_ids,n = 1,time_step = 3)
-    
     def run_model(self,name = None,overwrite_hbn = False): # NO STATE CHANGE 
         
         if name is None:
@@ -146,8 +142,8 @@ class calibrator:
         
         uci_file = self.model_path.joinpath(name + '.uci').as_posix()        
         self.uci.write(uci_file)
-        winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
-        subprocess.run([winHSPF,uci_file]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
+        #winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
+        subprocess.run([self.model.winHSPF,uci_file]) #, stdout=subprocess.PIPE, creationflags=0x08000000)
     
 
     def get_simulated_output(self,reach_ids,constituent,time_step = 'YE'):
@@ -155,13 +151,13 @@ class calibrator:
         sim.name = 'simulated'
         return sim
     
-    def get_observed_data(self,station_ids,constituent,time_step = 'YE'):
-        obs = self.dm._get_data(station_ids,constituent,agg_period = time_step).sort_index(level = 'index')
+    def get_observed_data(self,station_ids,constituent,time_step = 'YE',baseflow_percentage = None):
+        obs = self.dm.get_station_data(station_ids,constituent,agg_period = time_step)['observed'].sort_index(level = 'index')
         obs.name = 'observed'
         return obs
      
     
-    def compare_simulated_observed(self,station_ids,reach_ids,constituent,time_step,flow_station_ids = None, dropna = False):
+    def compare_simulated_observed(self,station_ids,reach_ids,constituent,time_step,flow_station_ids = None, dropna = False, baseflow_percentage = None):
         obs = self.get_observed_data(station_ids,constituent,time_step)
         sim = self.get_simulated_output(reach_ids,constituent,time_step = time_step)
         
@@ -177,11 +173,21 @@ class calibrator:
         # matching flow data
         sim_flow = self.get_simulated_output(reach_ids,'Q',time_step)
         sim_flow.name = 'simulated_flow'
+        sim_flow.columns = ['simulated_flow']
         df = df.join(sim_flow,how = 'inner')
         obs_flow = self.get_observed_data(flow_station_ids,'Q',time_step)
         obs_flow.name = 'observed_flow'
+        obs_flow.columns = ['observed_flow']
         df = df.join(obs_flow,how='left')
-        df.columns = ['simulated','observed','simulated_flow','observed_flow']
+
+        obs_baseflow = self.get_observed_data(flow_station_ids,'QB',time_step)
+        obs_baseflow.name = 'observed_baseflow'
+        obs_baseflow.columns = ['observed_baseflow']
+        df = df.join(obs_baseflow,how='left')
+        df.columns = ['simulated','observed','simulated_flow','observed_flow','observed_baseflow']
+        
+        if baseflow_percentage is not None:
+            df = df.loc[(df['observed_baseflow']/df['observed_flow'] >= baseflow_percentage/100)]
         
         # Add metadata
         df.attrs['station_ids'] = station_ids
@@ -225,14 +231,7 @@ class calibrator:
         obs_flow.name = 'observed_flow'
         df = df.join(obs_flow,how='left')
         df.columns = ['simulated','observed','simulated_flow','observed_flow']
-        # sim_flow = self.model.hbns.get_rchres_data('Q',reach_ids, 'cfs','D')
-        # sim_flow.name = 'simulated_flow'
-        # df = df.join(sim_flow,how = 'inner')
-        # obs_flow = pd.concat([self.dm.get_data(station_id,'Q','cfs','D') for station_id in station_ids])
-        # obs_flow.name = 'observed_flow'
-        # df = df.join(obs_flow,how='left')
-        # df.columns = ['simulated','observed','simulated_flow','observed_flow']
-        
+        # Add metadata
         df.attrs['station_ids'] = station_ids
         df.attrs['reach_ids'] = reach_ids
         df.attrs['constituent'] = constituent
@@ -271,7 +270,7 @@ class calibrator:
 
         return df_agg
 
-    def landcover(cal,constituent,ref_landcover = None):
+    def landcover(self,constituent,ref_landcover = None):
         def normalize_group(group, ref_landcover):
             if ref_landcover in group['LSID'].to_list():
                 ref_value = group.loc[group['LSID'] == ref_landcover, 'mean'].values[0]
@@ -281,19 +280,20 @@ class calibrator:
             return group
 
         if ref_landcover is None:
-            ref_landcover = cal.targets['uci_name'][cal.targets['dom_lc']==1].values[0]
+            ref_landcover = self.targets['uci_name'][self.targets['dom_lc']==1].values[0]
 
-        df = cal.model.hbns.get_perlnd_data(constituent)*2000 #tons/ac/yr to lbs/acr/year
-        df = df[(df.index >= cal.start_date) & (df.index <= cal.end_date)]
+        df = self.model.hbns.get_perlnd_data(constituent)*2000 #tons/ac/yr to lbs/acr/year
+        df = df[(df.index >= self.start_date) & (df.index <= self.end_date)]
         df = df.mean().rename('mean').to_frame()
-        df = pd.merge(df, cal.uci.opnid_dict['PERLND'], left_index = True,right_on='TOPFST', how='inner')
+        df = pd.merge(df, self.uci.opnid_dict['PERLND'], left_index = True,right_on='TOPFST', how='inner')
         df_normalized = pd.concat([normalize_group(group, ref_landcover) for _, group in list(df.groupby('metzone'))])
         
-        targets = cal.targets.set_index('uci_name')[constituent]
+        targets = self.targets.set_index('uci_name')[constituent]
         targets = targets/targets.loc[ref_landcover]
         
         df_normalized['target'] = targets.loc[df_normalized['LSID']].values/df_normalized['mean_norm']
         df_normalized = df_normalized.fillna(1) #don't make any changes to 0 concentration perlands
+        #df_normalized = df_normalized.join(self.uci.table('PERLND','SED-PARM3'))
         return df_normalized
 
 

pyhcal-1.1.1/src/pyhcal/mappers.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jan 27 11:20:47 2025
+
+@author: mfratki
+"""
+
+from pyhcal.repository import Repository
+from hspf.uci import UCI
+import geopandas as gpd
+import matplotlib.pyplot as plt
+import pandas as pd
+from pathlib import Path
+
+# Try to load statewide subwatersheds from data folder,
+
+# try:
+#     SUBWATERSHEDS = gpd.read_file(str(Path(__file__).resolve().parent/'data\\statewide_subwatersheds.gpkg'))
+# except:
+#     print("Could not load statewide subwatersheds. Please ensure the file 'statewide_subwatersheds.gpkg' is located in the 'data' folder of the pyhcal package.")
+    
+
+
+class uciMapper():
+    def __init__(self,model_names,gis_layer,huc6 = False):
+        self.mappers = []
+        
+        if huc6:
+            model_names = Repository.HUC_DIRECTORY.loc[Repository.HUC_DIRECTORY['Repository_HUC6 Name'].isin(model_names),'Repository_HUC8 Name']
+            model_names = model_names.loc[model_names.isin(Repository.valid_models())].values
+    
+        for model_name in model_names:
+            repo = Repository(model_name)
+            uci = UCI(repo.uci_file)
+            #gis_layer = SUBWATERSHEDS.loc[SUBWATERSHEDS['repo_name'] == model_name,:]
+            #gis_layer.set_index('SubID',inplace=True)
+            self.mappers.append(Mapper(model_name,uci,gis_layer))
+    
+    def map_parameter(self,operation,table_name,parameter,table_id):
+        table = self.join_table(operation,table_name,table_id)
+        fig, ax = plt.subplots()
+        #[table.plot(column = parameter,ax = ax) for table in tables]
+        table.plot(column = parameter,ax = ax,cmap='viridis',legend=True)
+        plt.title(parameter)
+    
+    def join_table(self,operation,table_name,table_id):
+        tables = [mapper.join_table(operation,table_name,table_id) for mapper in self.mappers]
+        table = pd.concat(tables)
+        return table
+    
+class Mapper():
+    def __init__(self,model_name,uci,subwatershed_gdf,hbn = None):
+        self.model_name = model_name
+        self.uci = uci
+        self.hbn = hbn
+        # if subwatershed_gdf is None:
+        #     subwatershed_gdf = SUBWATERSHEDS.loc[SUBWATERSHEDS['repo_name'] == model_name,:]
+        #     subwatershed_gdf.set_index('SubID',inplace=True)
+        
+        self.subwatershed_gdf = subwatershed_gdf
+        self.subwatersheds = uci.network.subwatersheds()
+        self.subwatershed_ids = list(set(self.subwatersheds.index))
+
+    def map_parameter(self,operation,table_name,parameter,table_id=0,weight_by_area = True):
+        fig, ax = plt.subplots()
+        self.join_table(operation,table_name,parameter,table_id).plot(column = parameter,ax = ax,cmap='viridis',legend=True)
+        plt.title(parameter)
+        
+    def join_table(self,operation,table_name,parameter,table_id=0,weight_by_area = True):
+        table = self.uci.table(operation,table_name,table_id)
+        subwatersheds = self.uci.network.subwatersheds()
+        subwatersheds = subwatersheds.loc[subwatersheds['SVOL'] == 'PERLND'].reset_index(drop=False).set_index('SVOLNO').join(table,how = 'left')
+        subwatersheds.index.name = 'SVOLNO' # Sometimes the index name gets dropped. I'm guessing when there are missing joins.
+        subwatersheds = subwatersheds.reset_index('SVOLNO').set_index(['SVOLNO','TVOLNO','SVOL','MLNO'])
+        
+        #weight by area factor:
+        if weight_by_area:
+            subwatersheds['weighted_param'] = subwatersheds['AFACTR']*subwatersheds[parameter]
+            subwatersheds = subwatersheds.groupby(subwatersheds.index.get_level_values('TVOLNO'))['weighted_param'].sum()/subwatersheds.groupby(subwatersheds.index.get_level_values('TVOLNO'))['AFACTR'].sum()
+            subwatersheds.name = parameter
+        else:
+            subwatersheds = subwatersheds.groupby(subwatersheds.index.get_level_values('TVOLNO'))[parameter].mean()
+            subwatersheds.name = parameter
+        return self.subwatershed_gdf.join(subwatersheds)
+ 
+    def map_flag():
+        raise NotImplementedError()
+        
+    def map_output(self,operation,output_name,t_code=5,agg_func = 'mean'):
+        subwatersheds = self.subwatersheds.loc[(self.subwatersheds['SVOL'] == operation),:].copy()
+        opnids = list(subwatersheds['SVOLNO'].unique())
+        output = self.hbn.get_multiple_timeseries(operation,t_code,output_name,opnids = opnids).agg(agg_func)
+        if operation in ['PERLND','IMPLND']:
+            subwatersheds = pd.merge(subwatersheds,output.to_frame(output_name),right_index = True,left_on = 'SVOLNO')
+            subwatersheds['area_output'] = subwatersheds['AFACTR']*subwatersheds[output_name]
+            subwatersheds = subwatersheds[['AFACTR','area_output']].groupby(subwatersheds.index).sum()
+            subwatersheds[output_name] = subwatersheds['area_output']/subwatersheds['AFACTR']
+        
+        fig, ax = plt.subplots()
+        #[table.plot(column = parameter,ax = ax) for table in tables]
+        self.subwatershed_gdf.join(subwatersheds).plot(column = output_name,ax = ax,cmap='viridis',legend=True)
+        plt.title(output_name)
+    
+        #return self.subwatershed_gdf.join(subwatersheds)
+

pyhcal-1.1.1/src/pyhcal/modl_db.py

@@ -0,0 +1,319 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu May  1 09:51:51 2025
+
+@author: mfratki
+"""
+#import sqlite3
+from pathlib import Path
+import geopandas as gpd
+import pandas as pd
+import duckdb
+#from hspf_tools.calibrator import etlWISKI, etlSWD
+
+
+#stations_wiski = gpd.read_file('C:/Users/mfratki/Documents/GitHub/pyhcal/src/pyhcal/data/stations_wiski.gpkg')
+
+
+_stations_wiski = gpd.read_file(str(Path(__file__).resolve().parent/'data\\stations_wiski.gpkg'))
+stations_wiski = _stations_wiski.dropna(subset='opnids')[['station_id','true_opnid','opnids','comments','modeled','repository_name','wplmn_flag']]
+stations_wiski['source'] = 'wiski'
+_stations_equis = gpd.read_file(str(Path(__file__).resolve().parent/'data\\stations_EQUIS.gpkg'))
+stations_equis = _stations_equis.dropna(subset='opnids')[['station_id','true_opnid','opnids','comments','modeled','repository_name']]
+stations_equis['source'] = 'equis'
+stations_equis['wplmn_flag'] = 0
+
+
+DB_PATH = str(Path(__file__).resolve().parent/'data\\outlets.duckdb')
+
+MODL_DB = pd.concat([stations_wiski,stations_equis])
+MODL_DB['opnids'] = MODL_DB['opnids'].str.strip().replace('',pd.NA)
+MODL_DB = MODL_DB.dropna(subset='opnids')
+MODL_DB = MODL_DB.drop_duplicates(['station_id','source']).reset_index(drop=True)
+
+def _reload():
+    global _stations_wiski, stations_wiski, _stations_equis, stations_equis, MODL_DB
+    _stations_wiski = gpd.read_file(str(Path(__file__).resolve().parent/'data\\stations_wiski.gpkg'))
+    stations_wiski = _stations_wiski.dropna(subset='opnids')[['station_id','true_opnid','opnids','comments','modeled','repository_name','wplmn_flag']]
+    stations_wiski['source'] = 'wiski'
+    _stations_equis = gpd.read_file(str(Path(__file__).resolve().parent/'data\\stations_EQUIS.gpkg'))
+    stations_equis = _stations_equis.dropna(subset='opnids')[['station_id','true_opnid','opnids','comments','modeled','repository_name']]
+    stations_equis['source'] = 'equis'
+    stations_equis['wplmn_flag'] = 0
+
+    MODL_DB = pd.concat([stations_wiski,stations_equis])
+    MODL_DB['opnids'] = MODL_DB['opnids'].str.strip().replace('',pd.NA)
+    MODL_DB = MODL_DB.dropna(subset='opnids')
+    MODL_DB = MODL_DB.drop_duplicates(['station_id','source']).reset_index(drop=True)
+
+
+def get_model_db(model_name: str):
+    return MODL_DB.query('repository_name == @model_name')
+
+def split_opnids(opnids: list):
+    return [abs(int(float(j))) for i in opnids for j in i]
+
+def valid_models():
+    return MODL_DB['repository_name'].unique().tolist()
+
+def wplmn_station_opnids(model_name):
+    opnids = MODL_DB.query('repository_name == @model_name and wplmn_flag == 1 and source == "wiski"')['opnids'].str.split(',').to_list()
+    return split_opnids(opnids)
+
+def wiski_station_opnids(model_name):
+    opnids = MODL_DB.query('repository_name == @model_name and source == "wiski"')['opnids'].str.split(',').to_list()
+    return split_opnids(opnids)
+
+def equis_station_opnids(model_name):
+    opnids = MODL_DB.query('repository_name == @model_name and source == "equis"')['opnids'].str.split(',').to_list()
+    return split_opnids(opnids)
+
+def station_opnids(model_name):
+    opnids = MODL_DB.query('repository_name == @model_name')['opnids'].str.split(',').to_list()
+    return split_opnids(opnids)
+
+def equis_stations(model_name):
+    return MODL_DB.query('repository_name == @model_name and source == "equis"')['station_id'].tolist()
+
+def wiski_stations(model_name):
+    return MODL_DB.query('repository_name == @model_name and source == "wiski"')['station_id'].tolist()
+
+def wplmn_stations(model_name):
+    return MODL_DB.query('repository_name == @model_name and wplmn_flag == 1 and source == "wiski"')['station_id'].tolist()
+
+def outlets(model_name):
+    return [group for _, group in MODL_DB.query('repository_name == @model_name').groupby(by = ['opnids','repository_name'])]
+
+def outlet_stations(model_name):
+    return [group['station_id'].to_list() for _, group in MODL_DB.query('repository_name == @model_name').groupby(by = ['opnids','repository_name'])]
+
+def _split_opnids(opnids: list):
+    return [int(float(j)) for i in opnids for j in i]
+
+def connect(db_path):
+    Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+    return duckdb.connect(db_path)
+
+
+def init_db(db_path: str,reset: bool = False):
+    """
+    Initialize the DuckDB database: create staging and analytics schemas
+    """
+    db_path = Path(db_path)
+    if reset and db_path.exists():
+        db_path.unlink()
+
+    with connect(db_path.as_posix()) as con:
+        con.execute(OUTLETS_SCHEMA)
+
+
+
+# Accessors:
+def get_outlets_by_model(model_name: str):
+    with connect(DB_PATH) as con:
+        df = con.execute(
+            """
+            SELECT r.*
+            FROM station_reach_pairs r
+            WHERE r.repository_name = ?
+            """,
+            [model_name]
+        ).fetchdf()
+    return df
+
+def get_outlets_by_reach(reach_id: int, model_name: str):
+    """
+    Return all outlet rows for outlets that include the given reach_id in the given model_name.
+    """
+    with connect(DB_PATH) as con:
+        df = con.execute(
+            """
+            SELECT r.*
+            FROM station_reach_pairs r
+            WHERE r.reach_id = ? AND r.repository_name = ?
+            """,
+        [reach_id, model_name]).fetchdf()
+    return df
+ 
+def get_outlets_by_station(station_id: str, station_origin: str):
+    """
+    Return all outlet rows for outlets that include the given reach_id in the given model_name.
+    """
+    with connect(DB_PATH) as con:
+
+        df = con.execute(
+        """
+        SELECT r.*
+        FROM station_reach_pairs r
+        WHERE r.station_id = ? AND r.station_origin = ?
+        """,
+        [station_id, station_origin]).fetchdf()
+    return df
+
+# constructors:
+def build_outlet_db(db_path: str = None):
+    if db_path is None:
+        db_path = DB_PATH
+    init_db(db_path,reset=True)
+    with connect(db_path) as con:
+        for index, (_, group) in enumerate(MODL_DB.drop_duplicates(['station_id','source']).groupby(by = ['opnids','repository_name'])):
+            repo_name = group['repository_name'].iloc[0]    
+            add_outlet(con, outlet_id = index, outlet_name = None, repository_name = repo_name, notes = None)
+            
+            opnids = set(_split_opnids(group['opnids'].str.split(',').to_list()))
+
+            for opnid in opnids:
+                if opnid < 0:
+                    exclude = 1
+                else:
+                    exclude = 0
+                add_reach(con, outlet_id = index, reach_id = abs(opnid),exclude = exclude, repository_name = repo_name)
+
+            for _, row in group.drop_duplicates(subset=['station_id', 'source']).iterrows():
+                add_station(con, outlet_id = index, station_id = row['station_id'], station_origin = row['source'], true_opnid = row['true_opnid'], repository_name= repo_name, comments = row['comments'])
+
+ 
+def create_outlet_schema(con, model_name : str):
+    for index, (_, group) in enumerate(modl_db.outlets(model_name)):
+        repo_name = group['repository_name'].iloc[0]    
+        add_outlet(con, outlet_id = index, outlet_name = None, repository_name = repo_name, notes = None)
+        
+        opnids = set(_split_opnids(group['opnids'].str.split(',').to_list()))
+
+        for opnid in opnids:
+            if opnid < 0:
+                exclude = 1
+            else:
+                exclude = 0
+            add_reach(con, outlet_id = index, reach_id = abs(opnid),exclude = exclude, repository_name = repo_name)
+
+        for _, row in group.drop_duplicates(subset=['station_id', 'source']).iterrows():
+            add_station(con, outlet_id = index, station_id = row['station_id'], station_origin = row['source'], true_opnid = row['true_opnid'], repository_name= repo_name, comments = row['comments'])
+
+
+def add_outlet(con,
+               outlet_id: str,
+               repository_name: str,
+               outlet_name = None,
+               notes = None):
+    """
+    Insert an outlet. repository_name is required.
+    """
+    con.execute(
+        "INSERT INTO outlets (outlet_id, repository_name, outlet_name, notes) VALUES (?, ?, ?, ?)",
+        [outlet_id, repository_name, outlet_name, notes]
+    )
+
+def add_station(con,
+                outlet_id: str,
+                station_id: str,
+                station_origin: str,
+                true_opnid: str,
+                repository_name: str,
+                comments = None):
+    """
+    Insert a station membership for an outlet.
+    Constraints:
+    - PRIMARY KEY (station_id, station_origin): unique per origin across all outlets.
+    - true_opnid and true_opnid_repository_name are required per schema.
+    """
+    con.execute(
+        """INSERT INTO outlet_stations
+           (outlet_id, station_id, station_origin, true_opnid, repository_name, comments)
+           VALUES (?, ?, ?, ?, ?, ?)""",
+        [outlet_id, station_id, station_origin, true_opnid, repository_name, comments]
+    )
+
+def add_reach(con,
+              outlet_id: str,
+              reach_id: str,
+              repository_name: str,
+              exclude: int = 0):
+    """
+    Insert a reach membership for an outlet.
+    - repository_name is required and participates in the PK (reach_id, repository_name).
+    - exclude = 1 to mark a reach as excluded from association views.
+    """
+    con.execute(
+        """INSERT INTO outlet_reaches (outlet_id, reach_id, repository_name, exclude)
+           VALUES (?, ?, ?, ?)""",
+        [outlet_id, reach_id, repository_name, int(exclude)]
+    )
+
+
+OUTLETS_SCHEMA  = """-- schema.sql
+-- Simple 3-table design to manage associations between model reaches and observation stations via outlets.
+-- Compatible with DuckDB and SQLite.
+
+-- Table 1: outlets
+-- Represents a logical grouping that ties stations and reaches together.
+CREATE TABLE IF NOT EXISTS outlets (
+  outlet_id TEXT PRIMARY KEY,
+  repository_name TEXT NOT NULL,
+  outlet_name TEXT,
+  notes TEXT             -- optional: general notes about the outlet grouping
+);
+
+-- Table 2: outlet_stations
+-- One-to-many: outlet -> stations
+CREATE TABLE IF NOT EXISTS outlet_stations (
+  outlet_id TEXT NOT NULL,
+  station_id TEXT NOT NULL,
+  station_origin TEXT NOT NULL,       -- e.g., 'wiski', 'equis'
+  repository_name TEXT NOT NULL,  -- repository model the station is physically located in
+  true_opnid TEXT NOT NULL,           -- The specific reach the station physically sits on (optional)
+  comments TEXT,             -- Per-station comments, issues, etc.
+  CONSTRAINT uq_station_origin UNIQUE (station_id, station_origin),
+  FOREIGN KEY (outlet_id) REFERENCES outlets(outlet_id)
+);
+
+-- Table 3: outlet_reaches
+-- One-to-many: outlet -> reaches
+-- A reach can appear in multiple outlets, enabling many-to-many overall.
+CREATE TABLE IF NOT EXISTS outlet_reaches (
+  outlet_id TEXT NOT NULL,
+  reach_id TEXT NOT NULL,    -- model reach identifier (aka opind)
+  repository_name TEXT NOT NULL,  -- optional: where the mapping comes from
+  exclude INTEGER DEFAULT 0, -- flag to indicate if this reach should be excluded (1) or included (0)
+  FOREIGN KEY (outlet_id) REFERENCES outlets(outlet_id)
+);
+
+-- Useful views:
+
+-- View: station_reach_pairs
+-- Derives the implicit many-to-many station <-> reach relationship via shared outlet_id
+CREATE VIEW IF NOT EXISTS station_reach_pairs AS
+SELECT
+  s.outlet_id,
+  s.station_id,
+  s.station_origin,
+  r.reach_id,
+  r.exclude,
+  r.repository_name,
+FROM outlet_stations s
+JOIN outlet_reaches r
+  ON s.outlet_id = r.outlet_id;
+
+-- Example indexes (SQLite will accept CREATE INDEX; DuckDB treats them as metadata but it’s okay to define):
+CREATE INDEX IF NOT EXISTS idx_outlet_stations_outlet ON outlet_stations(outlet_id);
+CREATE INDEX IF NOT EXISTS idx_outlet_reaches_outlet ON outlet_reaches(outlet_id);
+CREATE INDEX IF NOT EXISTS idx_station_reach_pairs_station ON outlet_stations(station_id);"""
+    
+    
+#row = modl_db.MODL_DB.iloc[0]
+
+#info = etlWISKI.info(row['station_id'])
+
+#modl_db.MODL_DB.query('source == "equis"')
+
+# outlet_dict = {'stations': {'wiski': ['E66050001'],
+#                'equis': ['S002-118']},
+#                'reaches': {'Clearwater': [650]}
+                      
+
+
+
+# station_ids = ['S002-118']
+# #station_ids = ['E66050001']
+# reach_ids = [650]
+# flow_station_ids =  ['E66050001']

{pyhcal-1.0.2 → pyhcal-1.1.1}/src/pyhcal/repository.py

@@ -6,7 +6,7 @@ Created on Wed Nov 27 09:16:30 2024
 """
 
 import pandas as pd
-from pyhcal.modl_db import MODL_DB
+from pyhcal import modl_db
 from pathlib import Path
 import shutil
 
@@ -20,7 +20,7 @@ class Repository():
                                                                                                                   'USGS HUC-4':'string',
                                                                                                                   'USGS HUC-2':'string'})
     
-    MODL_DB = MODL_DB
+    
 
     
     
@@ -38,7 +38,7 @@ class Repository():
         
         self.REPOSITORY_PATH = repository_path
         huc_directory = self.HUC_DIRECTORY.loc[self.HUC_DIRECTORY['Repository_HUC8 Name'] == model_name]
-        self.modl_db = self.MODL_DB.loc[self.MODL_DB['repository_name'] == model_name]
+        self.modl_db = modl_db.get_model_db(model_name) #self.MODL_DB.loc[self.MODL_DB['repository_name'] == model_name]
         #self.modl_db  = pd.concat([self.MODL_DB.loc[self.MODL_DB['repository_name'].str.startswith(huc8_id,na=False)] for huc8_id in huc8_ids])        
         self.model_name = model_name
         self.huc8_ids = list(huc_directory['USGS HUC-8'])
@@ -48,6 +48,9 @@ class Repository():
         self.uci_file = self.repo_folder.joinpath('HSPF','.'.join([self.model_name,'uci']))
         self.wdm_files = [item for item in self.repo_folder.joinpath('HSPF').iterdir() if (item.name.endswith('.wdm')) | (item.name.endswith('.WDM'))]
         self.shapefiles = {item.name.split('.')[0].split('_')[-1]:item for item in self.repo_folder.joinpath('GIS').iterdir() if (item.name.endswith('.shp')) | (item.name.endswith('.SHP'))}
+        self.wiski_stations = modl_db.wiski_stations(model_name)
+        self.equis_stations = modl_db.equis_stations(model_name)
+
 
     def copy(self,copy_path):
         copy_path = Path(copy_path)
@@ -73,7 +76,7 @@ class Repository():
             files = [file for file in shapefile.parent.iterdir() if file.stem == shapefile.stem]
             [shutil.copyfile(file,Path(copy_path).joinpath(Path(file).name)) for file in files]
             
-
+    
     
 def build_folders(trg_path):
     

{pyhcal-1.0.2 → pyhcal-1.1.1}/src/pyhcal/setup_utils.py

@@ -8,6 +8,7 @@ from mpcaHydro.data_manager import dataManager
 from hspf.wdmReader import readWDM
 from hspf.uci import UCI
 from pyhcal.repository import Repository
+from pyhcal import modl_db
 
 import numpy as np
 import pandas as pd
@@ -38,6 +39,8 @@ class Builder():
         self.new_uci = None
         self.uci = None
         self.dm = None
+        self.calibration_reaches = modl_db.wplmn_station_opnids(model_name)
+
     
     def valid_models():
         return Repository.valid_models()
@@ -65,44 +68,33 @@ class Builder():
         self.download_station_data()
         self.uci.build_targets().to_csv(self.project_path.joinpath('targets.csv'))
 
-        # if not self.project_path.joinpath('model',self.project_name + '_0-0.hbn').exists():
-        #     self.run_model()
-        
-    #TODO move to UCI class
     
     def format_uci(self,calibration_reaches = None):
-        
-        
+        if calibration_reaches is None:
+            calibration_reaches = self.calibration_reaches
+
         setup_files(self.uci,self.project_name,run = 0)
         setup_geninfo(self.uci)
-        
-        if calibration_reaches is None:
-            calibration_reaches = self.repository.modl_db.loc[self.repository.modl_db['wplmn_flag'] == 1]['opnids'].str.split(',').to_list()
-            calibration_reaches = [abs(int(j)) for i in calibration_reaches for j in i]        
-        #calibration_reaches = self.uci.network.station_order(calibration_reaches)[-1][0]
-        
-        
-        self.uci.initialize(name = self.project_name + '_0')
-        # for reaches in self._MODL_DB['opnids'].str.split('+').to_list():
-        #     [calibration_reaches.append(int(reach)) for reach in reaches if ~pd.isna(reach)]
-            
+        self.uci.initialize(name = self.project_name + '_0')  
         setup_binaryinfo(self.uci,reach_ids = calibration_reaches)
         setup_qualid(self.uci)
         self.uci.write(self.new_uci)
         
-        # Download observation data
-        # Sources/Databases WISKI and EQUIS (DELTA databases?)
-    #TODO: use a single WISKI etl script for csg and wplmn data
-    
-    
-    def download_station_data(self):#:,station_id,source_id):
-        stations = self.repository.modl_db.drop_duplicates(subset = ['source','station_id'])
-        if not stations.empty:
-            for index, row in stations.iterrows():
-                assert(row['source'].lower() in ['wiski','equis','swd'])
-                station_id = row['station_id']
-                self.dm.download_station_data(station_id,row['source'].lower())
-            
+    
+    def download_station_data(self,start_year,end_year):#:,station_id,source_id):
+        #%% Old approach. Store as indvidual processed station files then load to warehouse
+        if len(equis_stations) > 0:
+            if self.dm.credentials_exist():
+                station_origin = 'equis'
+            else: station_origin = 'swd'
+        
+            for station_id in equis_stations:
+                self.dm.download_station_data(station_id,station_origin, True)
+        
+        if len(wiski_stations) > 0:
+            for station_id in wiski_stations:
+                self.dm.download_station_data(station_id,'wiski', True)
+                 
     
     def convert_wdms(self):
         copy_path = Path(self.project_path.joinpath('model'))
@@ -111,11 +103,31 @@ class Builder():
             readWDM(wdm_file,
                     copy_path.joinpath(wdm_file.name.replace('.wdm','.hdf5').replace('.WDM','hdf5')))
         
-    def run_model(self):
+    def run_model(self, wait_for_completion=True):
+        #run_model(self.new_uci, wait_for_completion)
         # Run the uci file
         winHSPF = str(Path(__file__).resolve().parent.parent) + '\\bin\\WinHSPFLt\\WinHspfLt.exe'     
         subprocess.run([winHSPF,self.new_uci]) #, 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)
 
 
 
@@ -134,11 +146,12 @@ def setup_files(uci,name,run,n = 5):
     table = uci.table('FILES',drop_comments = False)
     for index, row in table.iterrows():
         filename = Path(row['FILENAME'])
-        if filename.suffix in ['.wdm','.ech','.out']:
+        if filename.suffix in ['.wdm','.ech','.out','.mut']:
             table.loc[index,'FILENAME'] = filename.name
-        if filename.suffix in ['.hbn']:
+        elif filename.suffix in ['.hbn']:
             table.loc[index,'FILENAME'] = filename.name
-        if filename.suffix in ['.plt']:
+        #if filename.suffix in ['.plt']:
+        else:
             table.drop(index,inplace = True)
             
     # Get new binary number and create new BINO rows

pyhcal-1.0.2/src/pyhcal/modl_db.py

@@ -1,97 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Thu May  1 09:51:51 2025
-
-@author: mfratki
-"""
-#import sqlite3
-from pathlib import Path
-import geopandas as gpd
-import pandas as pd
-#from hspf_tools.calibrator import etlWISKI, etlSWD
-
-
-#stations_wiski = gpd.read_file('C:/Users/mfratki/Documents/GitHub/pyhcal/src/pyhcal/data/stations_wiski.gpkg')
-
-
-stations_wiski = gpd.read_file(str(Path(__file__).resolve().parent/'data\\stations_wiski.gpkg')).dropna(subset='opnids')[['station_id','true_opnid','opnids','comments','modeled','repository_name','wplmn_flag']]
-stations_wiski['source'] = 'wiski'
-stations_equis = gpd.read_file(str(Path(__file__).resolve().parent/'data\\stations_EQUIS.gpkg')).dropna(subset='opnids')[['id_code','true_opnid','opnids','comments','modeled','repository_name']]
-stations_equis['source'] = 'equis'
-stations_equis['wplmn_flag'] = 0
-stations_equis = stations_equis.rename(columns = {'id_code':'station_id'})
-
-
-MODL_DB = pd.concat([stations_wiski,stations_equis])
-
-database  = """
-    -- Stations/Locations table
-    CREATE TABLE IF NOT EXISTS Station (
-        stationPK INTEGER PRIMARY KEY AUTOINCREMENT,
-        reachPK INTEGER REFERENCES Reach(reachPK),
-        stationID TEXT NOT NULL,
-        stationName TEXT,
-        stationOrigin TEXT NOT NULL,
-        latitude REAL,
-        longitude REAL,
-        stationType TEXT,
-        UNIQUE(stationID, stationOrigin)
-    );
-    
-    -- Station Associations table
-    CREATE TABLE IF NOT EXISTS StationAssociations (
-        stationPK INTEGER REFERENCES Station(stationPK),
-        associationPK INTEGER REFERENCES Station(stationPK)
-    );
-
-    -- Station Aliases table
-    CREATE TABLE IF NOT EXISTS StationAliases (
-        stationPK INTEGER NOT NULL,
-        aliasPK INTEGER NOT NULL,
-        FOREIGN KEY (stationPK) REFERENCES Station(stationPK),
-        FOREIGN KEY (aliasPK) REFERENCES Station(stationPK)
-    );
-    
-    CREATE TABLE Reach (
-        reachPK INTEGER PRIMARY KEY,
-        modelName TEXT NOT NULL,
-        reachID INTEGER NOT NULL,
-        drainageArea FLOAT 
-    );
-    
-    CREATE TABLE Outlet (
-        outletPK INTEGER PRIMARY KEY,
-        outletName TEXT
-    );
-    
-    -- Outlet-Station Associations table
-    CREATE TABLE IF NOT EXISTS StationAssociations (
-        outletPK INTEGER NOT NULL REFERENCES Outlet(outletPK),
-        stationPK  INTEGER NOT NULL REFERENCES Station(reachPK)
-    );
-    
-    -- Outlet-Reach Associations table
-    CREATE TABLE IF NOT EXISTS StationAssociations (
-        outletPK INTEGER NOT NULL REFERENCES Outlet(outletPK),
-        reachPK  INTEGER NOT NULL REFERENCES Station(reachPK)
-        exclude INTEGER NOT NULL
-    );"""
-    
-    
-#row = modl_db.MODL_DB.iloc[0]
-
-#info = etlWISKI.info(row['station_id'])
-
-#modl_db.MODL_DB.query('source == "equis"')
-
-# outlet_dict = {'stations': {'wiski': ['E66050001'],
-#                'equis': ['S002-118']},
-#                'reaches': {'Clearwater': [650]}
-                      
-
-
-
-# station_ids = ['S002-118']
-# #station_ids = ['E66050001']
-# reach_ids = [650]
-# flow_station_ids =  ['E66050001']