hspf 2.0.3__py3-none-any.whl → 2.1.1__py3-none-any.whl

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()
@@ -177,6 +178,43 @@ class UCI():
         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:
@@ -211,6 +249,9 @@ class UCI():
         self.merge_lines()
         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
         table = self.table('FILES',drop_comments = False) # initialize the table
@@ -325,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/validations.py

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Dec 23 17:33:46 2024
+
+@author: mfratki
+"""
+
+_COLUMN = 'ReachID'
+_DS_COLUMN = 'DS_ReachID'
+
+# %% Functions
+# First validate that the UCI file opn-sequence block is correct
+# Reaches
+# Is there an FTABLE?
+# Is it a lake reach?
+# Is it in the schematic block? Is there any acreage?
+# Is it in the ext sources block?
+# Is it in the
+
+#%% gis_layer methods
+
+def gis_upstream(reach, gis_layer):
+    return gis_layer.loc[gis_layer[_DS_COLUMN] == reach, _COLUMN].to_list()
+
+
+def gis_downstream(reach, gis_layer):
+    return gis_layer.loc[gis_layer[_COLUMN] == reach, _DS_COLUMN].to_list()
+
+
+def duplicates(gis_layer):
+    return gis_layer.loc[gis_layer.duplicated(subset=_COLUMN),_COLUMN].to_list()
+
+def is_duplicate(reach, gis_layer):
+    return len(gis_layer.loc[gis_layer[_COLUMN] == reach]) > 1
+
+def is_missing(reach, gis_layer):
+    return not any(gis_layer[_COLUMN].isin([reach]))
+
+#%% gis and uci checks
+
+def gis_only(gis_layer, uci):
+    return gis_layer.loc[~gis_layer[_COLUMN].isin(uci.valid_opnids['RCHRES']), _COLUMN]
+
+def missing(gis_layer, uci):
+    return [reach for reach in uci.valid_opnids['RCHRES'] if is_missing(reach, gis_layer)]
+
+
+#%% reach specific gis and uci checks
+
+
+def similar_area(reach,gis_layer,uci,tol = .05):
+    uci_area = uci.network.subwatershed_area(reach) 
+    gis_area = gis_layer.loc[gis_layer[_COLUMN] == reach].geometry.area*0.000247105 
+    
+    return abs((uci_area-gis_area)/uci_area) <= tol
+    
+def test_upstream(reach, gis_layer, uci):
+    # Is it a 0 order reach?
+    upstream = uci.network.upstream(reach)
+
+    us_pass = False
+    if len(upstream) == 0:
+        # Make sure the gis layer reach is not in the downstream reach id column
+        if not all(gis_layer[_DS_COLUMN] == reach):  # isin([reach])):
+            us_pass = True
+    else:
+        # if any(gis_layer.loc[gis_layer[_DS_COLUMN] == reach,_COLUMN].isin(upstream)):
+        if set(gis_layer.loc[gis_layer[_DS_COLUMN] == reach, _COLUMN]) == set(upstream):
+            us_pass = True
+    return us_pass
+
+
+def test_downstream(reach, gis_layer, uci):
+    # Is it a 0 order reach?
+    downstream = uci.network.downstream(reach)
+
+    ds_pass = False
+    if len(downstream) == 0:
+        if any(gis_layer.loc[gis_layer[_COLUMN] == reach, _DS_COLUMN].isin([999, -999])):
+            ds_pass = True
+    else:
+        if set(gis_layer.loc[gis_layer[_COLUMN] == reach, _DS_COLUMN]) == set(downstream):
+            ds_pass = True
+    return ds_pass
+
+
+#%% UCI checks
+def same_metzone(reachs, uci):
+    '''
+    Returns True if all reaches are located within the same metzone, otherwise returns False.
+    '''
+
+    return len(uci.opnid_dict['RCHRES'].loc[reachs, 'metzone'].unique()) == 1
+
+def same_metzone(reach_ids,uci):
+    dsn = uci.get_dsns('RCHRES',reach_ids[0],'PREC')['SVOLNO'].iloc[0]
+    mismatch = [reach_id for reach_id in reach_ids if uci.get_dsns('RCHRES',reach_id,'PREC')['SVOLNO'].iloc[0] != dsn]
+    return len(mismatch) == 0
+
+
+# def validate_subwatershed_metzone(reach,uci):
+#     subwatershed = uci.network.subwatershed(reach)
+#     reach_dsn = uci.get_dsns('RCHRES',reach,'PREC')
+#     subwatershed['dsns'] = pd.concat([uci.get_dsns(row['SVOL'],row['SVOLNO'],'PREC')['SVOLNO'] for index,row in subwatershed.iterrows()]).values
+
+
+def same_dsns(reach,uci):
+    reach_dsn = uci.get_dsns('RCHRES',reach,'PREC')['SVOLNO'].values[0]
+    diff = []
+    for index,row in uci.network.subwatershed(reach).iterrows():
+        perlnd_dsn = uci.get_dsns(row['SVOL'],row['SVOLNO'],'PREC')['SVOLNO'].values[0]
+        if perlnd_dsn != reach_dsn:
+            diff.append(perlnd_dsn)
+    return len(diff) == 0  
+            
+def has_ftable(reach, uci):
+    '''
+    Returns True if there is an FTABLE in the uci associated with the reach, otherwise returns False.
+    '''
+    return f'FTABLE{reach}' in uci.table_names('FTABLES')
+
+def isin_open_sequence(operation,opnid,uci):
+    opnseq = uci.table('OPN SEQUENCE')
+    return opnid in opnseq.loc[opnseq['OPERATION'] == operation,'SEGMENT'].values
+
+def isin_geninfo(reach, uci):
+    return reach in uci.table('RCHRES', 'GEN-INFO').index
+
+def isin_network(reach,uci):
+    return reach in uci.network.G.nodes
+
+def isin_schematic(reach, uci):
+    schematic = uci.table('SCHEMATIC')
+    return reach in set(schematic.loc[schematic['TVOL'] == 'RCHRES','TVOLNO'])
+    #return reach in uci.opnid_dict['RCHRES'].index
+
+def svol_isin_schematic(svol,svolnos,uci):
+    schematic = uci.table('SCHEMATIC')
+    schematic_svolnos = set(schematic.loc[schematic['SVOL'] == svol,'SVOLNO'])
+    out = {svolno:svolno in schematic_svolnos for svolno in svolnos}
+    if all(out.values()):
+        out = True
+    return out
+
+def tvol_isin_schematic(tvol,tvolnos,uci):
+    schematic = uci.table('SCHEMATIC')
+    schematic_tvolnos = set(schematic.loc[schematic['TVOL'] == tvol,'TVOLNO'])
+    out = {tvolno:tvolno in schematic_tvolnos for tvolno in tvolnos}
+    if all(out.values()):
+        out = True
+    return out
+
+def number_of_networks(uci):
+    return len(uci.network.outlets())
+
+def is_non_contributing_area(reach,uci):
+    return all([isin_schematic(reach,uci), not isin_network(reach,uci)])
+
+
+def isin_uci(reach, uci):
+    return reach in uci.valid_opnids['RCHRES']
+
+
+def has_area(reach, uci):
+    subwatersheds = uci.network.subwatersheds()
+    return reach in subwatersheds.index
+
+def gets_precip(reach, uci):
+    return reach in uci.network.G.nodes
+
+def is_routing_reach(reach, uci):
+    #return all([isin_network(reach,uci), not has_area(reach,uci)])
+    return uci.network.subwatershed(reach)['AFACTR'].sum() == 0
+
+
+def is_lake(reach, uci):
+    return uci.table('RCHRES', 'GEN-INFO').loc[reach, 'LKFG'] == 1
+
+# def recieves_met(reach,uci):
+#     ts_names = ['ATEM','CLOU','DEWP','PEVT','PREC','SOLR','WIND']
+#     return reach in set(ext_sources.loc[(ext_sources['TVOL'] == 'RCHRES') & (ext_sources['SMEMN'].isin(ts_names)),'TOPFST'])
+
+#%% In opensequence but not in scehamatic
+
+
+for model_name, uci in ucis.items():
+    reach_ids = uci.table('OPN SEQUENCE').query('OPERATION == "RCHRES"')['SEGMENT'].to_list()
+    schem = uci.table('SCHEMATIC')
+    if not all(schem.query('SVOL == "RCHRES"')['SVOLNO'].isin(reach_ids)):
+        print(model_name)
+
+
+'''
+Dummy Terminal Lake (Buffalo)
+
+A reach that acts as a termnial resevoir for upstream inflows. 
+No Ftable is needed since there is no routing (but perhaps some include them?)
+
+
+
+
+
+'''
+
+
+
+
+# opensequence
+# ext sources
+# schematic
+# 

hspf/warehouse.py

@@ -0,0 +1,275 @@
+import duckdb
+from pathlib import Path
+import pandas as pd
+
+def init_hspf_db(db_path: str, reset: bool = False):
+    """Initializes the HSPF model structure database."""
+    db_path = Path(db_path)
+    if reset and db_path.exists():
+        db_path.unlink()
+
+    with duckdb.connect(db_path.as_posix()) as con:
+        # Create schema
+        con.execute("CREATE SCHEMA IF NOT EXISTS hspf")
+        
+        # Create tables for HSPF model data
+        create_model_tables(con)
+        create_model_run_table(con)
+        create_structure_tables(con)
+        create_parameter_tables(con)
+        create_timeseries_tables(con)
+        # ...and so on for all HSPF tables...
+
+def load_df_to_table(con: duckdb.DuckDBPyConnection, df: pd.DataFrame, table_name: str, replace: bool = True):
+    """
+    Persist a pandas DataFrame into a DuckDB table. This will overwrite the table
+    by default (replace=True).
+    """
+    if replace:
+        con.execute(f"DROP TABLE IF EXISTS {table_name}")
+    # register pandas DF and create table
+    con.register("tmp_df", df)
+    con.execute(f"CREATE TABLE {table_name} AS SELECT * FROM tmp_df")
+    con.unregister("tmp_df")
+
+
+def create_hspf_model_hierarchy_tables(con: duckdb.DuckDBPyConnection):
+    """
+    Creates the tables that define the model -> version -> scenario -> run hierarchy.
+    """
+    con.execute('''
+    CREATE SEQUENCE IF NOT EXISTS hspf.model_seq START 1;
+    CREATE SEQUENCE IF NOT EXISTS hspf.model_version_seq START 1;
+    CREATE SEQUENCE IF NOT EXISTS hspf.scenario_seq START 1;
+    CREATE SEQUENCE IF NOT EXISTS hspf.model_run_seq START 1;
+
+    -- Level 1: The overall Model (e.g., for a specific basin)
+    CREATE TABLE IF NOT EXISTS hspf.models (
+        model_pk        BIGINT PRIMARY KEY DEFAULT nextval('hspf.model_seq'),
+        model_name      VARCHAR NOT NULL UNIQUE, -- e.g., 'Nemadji River Basin Model'
+        description     VARCHAR
+    );
+
+    -- Level 2: A specific Version of a Model
+    CREATE TABLE IF NOT EXISTS hspf.model_versions (
+        model_version_pk BIGINT PRIMARY KEY DEFAULT nextval('hspf.model_version_seq'),
+        model_pk         BIGINT NOT NULL REFERENCES hspf.models(model_pk),
+        version_name     VARCHAR NOT NULL, -- e.g., 'v2.1', '2025_Update'
+        release_date     DATE,
+        description      VARCHAR,
+        UNIQUE (model_pk, version_name)
+    );
+
+    -- Level 3: A Scenario within a Model Version
+    CREATE TABLE IF NOT EXISTS hspf.scenarios (
+        scenario_pk      BIGINT PRIMARY KEY DEFAULT nextval('hspf.scenario_seq'),
+        model_version_pk BIGINT NOT NULL REFERENCES hspf.model_versions(model_version_pk),
+        scenario_name    VARCHAR NOT NULL, -- e.g., 'Baseline_2020', 'Future_Climate_BMPs'
+        description      VARCHAR,
+        UNIQUE (model_version_pk, scenario_name)
+    );
+
+    -- Level 4: A single execution (Run) of a Scenario
+    CREATE TABLE IF NOT EXISTS hspf.model_runs (
+        model_run_pk   BIGINT PRIMARY KEY DEFAULT nextval('hspf.model_run_seq'),
+        scenario_pk    BIGINT NOT NULL REFERENCES hspf.scenarios(scenario_pk),
+        run_id         BIGINT,
+        run_name       VARCHAR,          -- e.g., 'Run_1995-2015', 'Calibration_Run_A'
+        start_year     INTEGER,
+        end_year       INTEGER,
+        run_timestamp  TIMESTAMP DEFAULT current_timestamp,
+        notes          VARCHAR
+    );
+    ''')
+
+def create_model_run_table(con: duckdb.DuckDBPyConnection):
+    """
+    Creates the table to store individual model runs linked to scenarios.
+    """
+    con.execute(
+    '''
+    CREATE SEQUENCE IF NOT EXISTS model_run_seq START 1;
+
+    -- Table: hspf.model_runs
+    -- Purpose: Stores individual model runs linked to scenarios.
+    CREATE TABLE IF NOT EXISTS model_runs (
+        model_run_pk   BIGINT PRIMARY KEY DEFAULT nextval('model_run_seq'),
+        model_name     VARCHAR NOT NULL, -- e.g., 'Nemadji River Basin Model'
+        run_id         BIGINT,
+        run_name       VARCHAR,          -- e.g., 'Run_1995-2015', 'Calibration_Run_A'
+        notes          VARCHAR
+    );
+    ''')
+
+def insert_model_run(con: duckdb.DuckDBPyConnection, model_name: str, run_id: int, run_name: str = None, notes: str = None):
+    """
+    Inserts a new model run into the model_runs table.
+    """
+    con.execute(
+        '''
+        INSERT INTO model_runs (model_name, run_id, run_name, notes)
+        VALUES (?, ?, ?, ?)
+        ''',
+        (model_name, run_id, run_name, notes)
+    )
+
+def create_structure_tables(con: duckdb.DuckDBPyConnection):
+    """
+    Creates tables that define the structural components of an HSPF model,
+    linking them to a core model definition.
+    """
+    con.execute(
+    '''
+    CREATE SEQUENCE IF NOT EXISTS hspf.operation_seq START 1;
+    CREATE SEQUENCE IF NOT EXISTS hspf.catchment_seq START 1;
+
+    -- Table: hspf.operations
+    -- Purpose: Registry of all land segments and reaches (e.g., PERLND, RCHRES).
+    CREATE TABLE IF NOT EXISTS hspf.operations (
+        operation_pk     BIGINT PRIMARY KEY DEFAULT nextval('hspf.operation_seq'),
+        model_pk         BIGINT NOT NULL REFERENCES hspf.models(model_pk),
+        operation_id     INTEGER NOT NULL,       -- e.g., The PERLND number (101)
+        operation_type   VARCHAR NOT NULL,       -- e.g., 'PERLND', 'RCHRES'
+        UNIQUE (model_pk, operation_id, operation_type)
+    );
+
+
+    -- Table: hspf.catchments
+    -- Purpose: Defines the subwatersheds or catchments in the model.
+    CREATE TABLE IF NOT EXISTS hspf.catchments (
+        catchment_pk      BIGINT PRIMARY KEY DEFAULT nextval('hspf.catchment_seq'),
+        model_pk          BIGINT NOT NULL REFERENCES hspf.models(model_pk),
+        catchment_id      INTEGER NOT NULL,
+        catchment_name    VARCHAR,
+        UNIQUE (model_pk, catchment_id)
+    );
+
+    -- Table: hspf.catchment_operations
+    -- Purpose: Maps operations (land segments) to catchments, defining the model's spatial structure and connectivity.
+    CREATE TABLE IF NOT EXISTS hspf.catchment_operations (
+        catchment_pk          BIGINT REFERENCES hspf.catchments(catchment_pk),
+        source_operation_pk   BIGINT REFERENCES hspf.operations(operation_pk),
+        target_operation_pk   BIGINT REFERENCES hspf.operations(operation_pk),
+        model_pk              BIGINT NOT NULL REFERENCES hspf.models(model_pk),
+        value                 FLOAT,
+        mlno                  INTEGER, -- Mass-link number from SCHEMATIC block
+        tmemsb1               INTEGER, -- Mass-link memory storage 1
+        tmemsb2               INTEGER  -- Mass-link memory storage 2
+    );
+    ''')
+
+
+def create_parameter_tables(con: duckdb.DuckDBPyConnection):
+    """
+    Creates tables to store the parameters, flags, and properties for model operations,
+    linking them to the model structure.
+    """
+    con.execute(
+    '''
+    CREATE SEQUENCE IF NOT EXISTS hspf.parameter_seq START 1;
+    CREATE SEQUENCE IF NOT EXISTS hspf.flag_seq START 1;
+    CREATE SEQUENCE IF NOT EXISTS hspf.property_seq START 1;
+
+    -- Table: hspf.parameters
+    -- Purpose: Stores numeric model parameters for each operation (e.g., LZSN, UZSN).
+    CREATE TABLE IF NOT EXISTS hspf.parameters (
+        parameter_pk      BIGINT PRIMARY KEY DEFAULT nextval('hspf.parameter_seq'),
+        operation_pk      BIGINT NOT NULL REFERENCES hspf.operations(operation_pk),
+        parameter_name    VARCHAR,
+        parameter_value   FLOAT
+    );
+
+    -- Table: hspf.flags
+    -- Purpose: Stores integer-based flags for model operations (e.g., snow flags).
+    CREATE TABLE IF NOT EXISTS hspf.flags (
+        flag_pk           BIGINT PRIMARY KEY DEFAULT nextval('hspf.flag_seq'),
+        operation_pk      BIGINT NOT NULL REFERENCES hspf.operations(operation_pk),
+        flag_name         VARCHAR,
+        flag_value        INTEGER
+    );
+
+    -- Table: hspf.properties
+    -- Purpose: Stores string-based properties for model operations (e.g., land use names).
+    CREATE TABLE IF NOT EXISTS hspf.properties (
+        property_pk       BIGINT PRIMARY KEY DEFAULT nextval('hspf.property_seq'),
+        operation_pk      BIGINT NOT NULL REFERENCES hspf.operations(operation_pk),
+        property_name     VARCHAR,
+        property_value    VARCHAR
+    );
+    ''')
+
+
+def create_timeseries_tables(con: duckdb.DuckDBPyConnection):
+    """
+    Creates tables for storing model output timeseries, linking them to a specific model run.
+    """
+    con.execute(
+    '''
+    CREATE SEQUENCE IF NOT EXISTS timeseries_metadata_seq START 1;
+
+    -- Table: hspf.timeseries_metadata
+    -- Purpose: Metadata for each unique timeseries produced by a model run.
+    CREATE TABLE IF NOT EXISTS hspf.timeseries_metadata (
+        timeseries_pk     BIGINT PRIMARY KEY DEFAULT nextval('timeseries_metadata_seq'),
+        model_run_pk      BIGINT NOT NULL REFERENCES model_runs(model_run_pk),
+        operation_pk      BIGINT NOT NULL REFERENCES operations(operation_pk),
+        ts_name           VARCHAR NOT NULL,     -- e.g., 'ROVOL','SOSED'
+        activity          VARCHAR NOT NULL,     -- e.g., 'SEDTRN','HYDR'
+        timestep          VARCHAR NOT NULL,     -- e.g., 'hourly','daily'
+        unit              VARCHAR NOT NULL,     -- e.g., 'cfs','mg/L'
+        timeseries_type   VARCHAR NOT NULL  -- e.g., 'cumulative', 'instantaneous'
+    );
+
+    -- Table: hspf.timeseries
+    -- Purpose: Stores the actual timeseries data points in a narrow/long format.
+    CREATE TABLE IF NOT EXISTS hspf.timeseries (
+        timeseries_pk BIGINT NOT NULL REFERENCES timeseries_metadata(timeseries_pk),
+        datetime      TIMESTAMP NOT NULL,
+        value         DOUBLE,
+        UNIQUE(timeseries_pk, datetime)
+    );
+    ''')
+
+def connect(db_path: str, read_only: bool = False) -> duckdb.DuckDBPyConnection:
+    db_path = Path(db_path)
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    return duckdb.connect(database=db_path.as_posix(), read_only=read_only)
+
+def insert_df_into_table(con: duckdb.DuckDBPyConnection, df: pd.DataFrame, table_name: str, schema: str = 'hspf', clear_before_insert: bool = True):
+    """
+    Inserts a pandas DataFrame into an existing table in a specified schema,
+    matching columns by name, making the operation robust to column order.
+
+    Args:
+        con: The DuckDB connection object.
+        df: The pandas DataFrame to insert.
+        table_name: The name of the target table.
+        schema: The schema of the target table (e.g., 'hspf', 'analytics').
+        clear_before_insert: If True, deletes all rows from the table before insertion.
+    """
+    target_table = f"{schema}.{table_name}"
+    
+    if not df.empty:
+        if clear_before_insert:
+            print(f"  Clearing all data from {target_table}...")
+            con.execute(f"DELETE FROM {target_table}")
+
+        # Get column names from the DataFrame and format them for the SQL query.
+        # Quoting column names handles special characters, spaces, and case-sensitivity.
+        cols = df.columns
+        col_string = ", ".join([f'"{c}"' for c in cols])
+        
+        # Register the DataFrame as a temporary view so we can query it
+        temp_view_name = "temp_df_to_insert"
+        con.register(temp_view_name, df)
+
+        print(f"  Inserting {len(df)} rows into {target_table}...")
+        
+        # The SQL statement is now robust to column order in the DataFrame
+        sql = f"INSERT INTO {target_table} ({col_string}) SELECT {col_string} FROM {temp_view_name}"
+        con.execute(sql)
+
+        # Clean up the temporary view
+        con.unregister(temp_view_name)
+    else:
+        print(f"  DataFrame is empty. Skipping insertion into {target_table}.")

{hspf-2.0.3.dist-info → hspf-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hspf
-Version: 2.0.3
+Version: 2.1.1
 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.3.dist-info → hspf-2.1.1.dist-info}/RECORD

@@ -1,11 +1,22 @@
+hspf/Masslink_Timeseries.csv,sha256=TOV6PpR0SBI0FaAU1T-qyD2DyGsBFjUWZenvWXiS3wA,4985
 hspf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hspf/hbn.py,sha256=SQMxWllZy5OxWGMkhmjiardb8vbSjrmENJrorLBqTDI,19476
-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=towPqQYFO1JC1yNHG5gHoM_8jeO-XueSmClheSth-5k,31612
+hspf/build_warehouse.py,sha256=J3fgycY9xkZdY3C9u0wDaEX1n6satr1t0mQmfg4Fh6E,20205
+hspf/hbn.py,sha256=xUvovcAXXLLLE_ID9kejjiyaAqnh-vwmDLdPLjsGQ8A,19401
+hspf/hbn2.py,sha256=OmuTVDxd0Boyd3GvBgzEfqvP7CTeYIJYPC7EXPgYu30,13190
+hspf/hbn_cy.c,sha256=ZIJwWxyGx8fE5nM1HBd8-zNotmStGZscqXijl3KSRdI,593464
+hspf/hbn_cy.html,sha256=o8wMdvEE547DRXcUHFPgAkkyJ665b6rloGL-qKClaTo,137735
+hspf/hbn_cy.pyx,sha256=T-itpkvHlxHzQHKtJBS-M8_ToLBa1U_ajpV53hh_oI8,4323
+hspf/helpers.py,sha256=cd8J3XfCFmpER475Mk5aFL29612rgop75GRGxlofXQo,3242
+hspf/hspfModel.py,sha256=K_xF7HtuMpDMod56Z3IXDCeGsnUi8KGhly_9tm-mxoY,9070
+hspf/reports.py,sha256=bU9rU9qaffXosxyA3H5OWi4SqQVPiQh6709tTCMYeeU,46286
+hspf/uci.py,sha256=rsi_KJqdfBFp0rlKCHyhmQGdB_rgNE8k6abTjH26UqE,33982
+hspf/validations.py,sha256=BcNT0h5QDZW9lHpXk8KuHQvycl8a_4jQ91srwWFodRo,6666
+hspf/warehouse.py,sha256=1zm1uu_QvevIuAMNPOkzspnFhNpLQrvkq3x3HXSypGg,11898
 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/HSPFParameterRanges.csv,sha256=PKz1DRIgpsgTEDrVaSHB9SAGMa5yUBRpyZDc9-CKJJo,28357
+hspf/data/LandUseNames_Mappings.csv,sha256=Bb2toZn6FkPfZ6_8SnzIQvXJ03ycwCuc8uyv4cUowNY,75899
 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 +38,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=bAOCkOwubRoETRWlOP_apOFyepV-yHSeCYPYVyuZ2bE,28610
-hspf/parser/parsers.py,sha256=xlWB-odGNrArdvd5qwGyvNZ0N8oaVmuNZ6z3gRdHm-g,19796
-hspf-2.0.3.dist-info/METADATA,sha256=qyqFAALOQR0L2W62BIsBRD65-CwPF2Ue2iFJEK8-Jdc,605
-hspf-2.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hspf-2.0.3.dist-info/RECORD,,
+hspf/parser/graph.py,sha256=jvkjz9eNtBFEmxUeQosuQE7XgsIRlrNH-rSny5KBDoE,33046
+hspf/parser/parsers.py,sha256=x3othxQogUmGNe_ctCU20atDrRM_B4lEbVJb3EMbwto,20850
+hspf-2.1.1.dist-info/METADATA,sha256=KtAPnc8v-bT8ow30iHdN1lCm2asH22rvOyKgDGS_kL0,605
+hspf-2.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hspf-2.1.1.dist-info/RECORD,,

{hspf-2.0.3.dist-info → hspf-2.1.1.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