mpcaHydro 2.1.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

mpcaHydro/warehouse.py

@@ -1,6 +1,7 @@
 import duckdb
 import pandas as pd
 from pathlib import Path
+from mpcaHydro import outlets
 
 def init_db(db_path: str,reset: bool = False):
     """
@@ -14,14 +15,14 @@ def init_db(db_path: str,reset: bool = False):
         # Create all schemas
         create_schemas(con)
 
-        # Create tables for observational data
-        # Wrapped in try/except as they depend on tables that may not exist yet
-        try:
-            create_combined_observations_view(con)
-            create_constituent_summary_report(con)
-        except duckdb.CatalogException as e:
-            print(f"Could not create observation views, likely because backing tables don't exist yet. This is safe to ignore on first run. Details: {e}")
+        # Create tables
+        create_outlets_tables(con)
+        create_mapping_tables(con)
+        create_analytics_tables(con)
 
+        # Create views
+        #update_views(con)
+        
 
 def create_schemas(con: duckdb.DuckDBPyConnection):
     """
@@ -30,8 +31,245 @@ def create_schemas(con: duckdb.DuckDBPyConnection):
     con.execute("CREATE SCHEMA IF NOT EXISTS staging")
     con.execute("CREATE SCHEMA IF NOT EXISTS analytics")
     con.execute("CREATE SCHEMA IF NOT EXISTS reports")
-    con.execute("CREATE SCHEMA IF NOT EXISTS hspf")
+    con.execute("CREATE SCHEMA IF NOT EXISTS outlets")
+    con.execute("CREATE SCHEMA IF NOT EXISTS mappings")
 
+def create_analytics_tables(con: duckdb.DuckDBPyConnection):
+    """
+    Create necessary tables in the analytics schema.
+    """
+    con.execute("""
+    CREATE TABLE IF NOT EXISTS analytics.equis (
+        datetime TIMESTAMP,
+        value DOUBLE,
+        station_id TEXT,
+        station_origin TEXT,
+        constituent TEXT,
+        unit TEXT
+    );
+    """)
+    con.execute("""
+    CREATE TABLE IF NOT EXISTS analytics.wiski (
+        datetime TIMESTAMP,
+        value DOUBLE,
+        station_id TEXT,
+        station_origin TEXT,
+        constituent TEXT,
+        unit TEXT
+    );
+    """)
+
+def create_mapping_tables(con: duckdb.DuckDBPyConnection):
+    """
+    Create and populate tables in the mappings schema from Python dicts and CSVs.
+    """
+    # WISKI parametertype_id -> constituent
+    wiski_parametertype_map = {
+        '11522': 'TP', 
+        '11531': 'TP', 
+        '11532': 'TSS', 
+        '11523': 'TSS',
+        '11526': 'N', 
+        '11519': 'N', 
+        '11520': 'OP', 
+        '11528': 'OP',
+        '11530': 'TKN', 
+        '11521': 'TKN', 
+        '11500': 'Q', 
+        '11504': 'WT',
+        '11533': 'DO', 
+        '11507': 'WL'
+    }
+    df_wiski_params = pd.DataFrame(wiski_parametertype_map.items(), columns=['parametertype_id', 'constituent'])
+    con.execute("CREATE TABLE IF NOT EXISTS mappings.wiski_parametertype AS SELECT * FROM df_wiski_params")
+
+    # EQuIS cas_rn -> constituent
+    equis_casrn_map = {
+        '479-61-8': 'CHLA', 
+        'CHLA-CORR': 'CHLA', 
+        'BOD': 'BOD', 
+        'NO2NO3': 'N',
+        '14797-55-8': 'NO3', 
+        '14797-65-0': 'NO2', 
+        '14265-44-2': 'OP',
+        'N-KJEL': 'TKN', 
+        'PHOSPHATE-P': 'TP', 
+        '7723-14-0': 'TP',
+        'SOLIDS-TSS': 'TSS', 
+        'TEMP-W': 'WT', 
+        '7664-41-7': 'NH3'
+    }
+    df_equis_cas = pd.DataFrame(equis_casrn_map.items(), columns=['cas_rn', 'constituent'])
+    con.execute("CREATE TABLE IF NOT EXISTS mappings.equis_casrn AS SELECT * FROM df_equis_cas")
+
+    # Load station cross-reference from CSV
+    # Assumes this script is run from a location where this relative path is valid
+    xref_csv_path = Path(__file__).parent / 'data/WISKI_EQUIS_XREF.csv'
+    if xref_csv_path.exists():
+        con.execute(f"CREATE TABLE IF NOT EXISTS mappings.station_xref AS SELECT * FROM read_csv_auto('{xref_csv_path.as_posix()}')")
+    else:
+        print(f"Warning: WISKI_EQUIS_XREF.csv not found at {xref_csv_path}")
+
+    # Load wiski_quality_codes from CSV
+    wiski_qc_csv_path = Path(__file__).parent / 'data/WISKI_QUALITY_CODES.csv'
+    if wiski_qc_csv_path.exists():
+        con.execute(f"CREATE TABLE IF NOT EXISTS mappings.wiski_quality_codes AS SELECT * FROM read_csv_auto('{wiski_qc_csv_path.as_posix()}')")
+    else:
+            print(f"Warning: WISKI_QUALITY_CODES.csv not found at {wiski_qc_csv_path}")
+
+def create_outlets_tables(con: duckdb.DuckDBPyConnection):
+    """
+    Create tables in the outlets schema to define outlet-station-reach relationships.
+    """
+    con.execute("""-- 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.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 outlets.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.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 outlets.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.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 outlets.station_reach_pairs AS
+            SELECT
+            s.outlet_id,
+            s.station_id,
+            s.station_origin,
+            r.reach_id,
+            r.exclude,
+            r.repository_name,
+            FROM outlets.outlet_stations s
+            JOIN outlets.outlet_reaches r
+            ON s.outlet_id = r.outlet_id;
+
+          """)
+
+def create_normalized_wiski_view(con: duckdb.DuckDBPyConnection):
+    """
+    Create a view in the database that contains normalized WISKI data.
+    Units converted to standard units.
+    columns renamed.
+    constituents mapped.
+    """
+    con.execute("""
+    -- Create a single view with all transformations
+    CREATE OR REPLACE VIEW analytics.wiski_normalized AS
+    SELECT 
+        
+        -- Convert °C to °F and keep other values unchanged
+        CASE 
+            WHEN LOWER(ts_unitsymbol) = '°c' THEN (value * 9.0 / 5.0) + 32
+            WHEN ts_unitsymbol = 'kg' THEN value * 2.20462    -- Convert kg to lb
+            ELSE value
+        END AS value,
+
+        -- Normalize units
+        CASE 
+            WHEN LOWER(ts_unitsymbol) = '°c' THEN 'degf'      -- Normalize °C to degF
+            WHEN ts_unitsymbol = 'kg' THEN 'lb'              -- Normalize kg to lb
+            WHEN ts_unitsymbol = 'ft³/s' THEN 'cfs'          -- Rename ft³/s to cfs
+            ELSE ts_unitsymbol
+        END AS unit,
+
+        -- Normalize column names
+        station_no AS station_id,                             -- Rename station_no to station_id
+        Timestamp AS datetime,                                -- Rename Timestamp to datetime
+        "Quality Code" AS quality_code,                      -- Rename Quality Code to quality_code
+        "Quality Code Name" AS quality_code_name,            -- Rename Quality Code Name to quality_code_name
+        parametertype_id,                                    -- Keeps parametertype_id as is
+        constituent                                          -- Keeps constituent as is
+    FROM staging.wiski_raw;""")
+
+
+def create_filtered_wiski_view(con: duckdb.DuckDBPyConnection, data_codes: list):
+    """
+    Create a view in the database that filters WISKI data based on specified data codes.
+    """
+    query = f"""
+    CREATE OR REPLACE VIEW analytics.wiski_filtered AS
+    SELECT *
+    FROM analytics.wiski_normalized
+    WHERE quality_code IN ({placeholders});
+    """
+
+    placeholders = ', '.join(['?'] * len(data_codes))
+    query = query.format(placeholders=placeholders)
+    con.execute(query, data_codes)
+
+
+def create_aggregated_wiski_view(con: duckdb.DuckDBPyConnection):
+    """
+    Create a view in the database that aggregates WISKI data by hour, station, and constituent.
+    """
+    con.execute("""
+    CREATE OR REPLACE Table analytics.wiski_aggregated AS
+    SELECT 
+        station_id,
+        constituent,
+        time_bucket(INTERVAL '1 hour', datetime) AS hour_start,
+        AVG(value) AS value,
+        unit
+    FROM analytics.wiski_normalized
+    GROUP BY 
+        station_id, 
+        constituent, 
+        hour_start,
+        unit;
+    """)
+
+def create_staging_qc_count_view(con: duckdb.DuckDBPyConnection):
+    """
+    Create a view in staging schema that counts quality codes for each station and constituent.
+    """
+    con.execute("""
+    CREATE OR REPLACE VIEW staging.wiski_qc_count AS (
+        SELECT 
+            w.station_no,
+            w.parametertype_name,
+            w."Quality Code",
+            w."Quality Code Name",
+            COUNT(w."Quality Code") AS count
+        FROM staging.wiski_raw w 
+        GROUP BY
+            w."Quality Code",w."Quality Code Name",w.parametertype_name, w.station_no
+                );
+        """)
+    # ORDER BY
+    #         w.station_no,w.parametertype_name, w."Quality Code"
+    #         )
+    # """)
 
 def create_combined_observations_view(con: duckdb.DuckDBPyConnection):
     """
@@ -47,6 +285,87 @@ def create_combined_observations_view(con: duckdb.DuckDBPyConnection):
     """)
 
 
+def create_outlet_observations_view(con: duckdb.DuckDBPyConnection):
+    """
+    Create a view in analytics schema that links observations to model reaches via outlets.
+    """
+    con.execute("""
+    CREATE OR REPLACE VIEW analytics.outlet_observations AS 
+    SELECT
+        o.datetime,
+        os.outlet_id,
+        o.constituent,
+        AVG(o.value) AS value,
+        COUNT(o.value) AS count
+    FROM
+        analytics.observations AS o
+    LEFT JOIN
+        outlets.outlet_stations AS os ON o.station_id = os.station_id AND o.station_origin = os.station_origin
+    GROUP BY
+        os.outlet_id,
+        o.constituent,
+        o.datetime; -- Group by the truncated date
+    """)
+    # ORDER BY
+    #     os.outlet_id,
+    #     o.constituent,
+    #     datetime);
+
+
+
+def create_outlet_observations_with_flow_view(con: duckdb.DuckDBPyConnection):
+    
+    con.execute("""
+    CREATE OR REPLACE VIEW analytics.outlet_observations_with_flow AS 
+        WITH baseflow_data AS (
+            SELECT
+                outlet_id,
+                datetime,
+                "value" AS baseflow_value
+            FROM
+                analytics.outlet_observations
+            WHERE
+                (constituent = 'QB')),
+        flow_data AS (
+            SELECT
+                outlet_id,
+                datetime,
+                "value" AS flow_value
+            FROM
+                analytics.outlet_observations
+            WHERE
+                (constituent = 'Q')),
+        constituent_data AS (
+            SELECT
+                outlet_id,
+                datetime,
+                constituent,
+                "value",
+                count
+            FROM
+                analytics.outlet_observations
+            WHERE
+                (constituent NOT IN ('Q', 'QB')))
+        SELECT
+            constituent_data.outlet_id,
+            constituent_data.constituent,
+            constituent_data.datetime,
+            constituent_data."value",
+            flow_data.flow_value,
+            baseflow_data.baseflow_value
+        FROM
+            constituent_data
+        FULL JOIN flow_data ON
+            (((constituent_data.outlet_id = flow_data.outlet_id)
+                AND (constituent_data.datetime = flow_data.datetime)))
+        LEFT JOIN baseflow_data ON
+            (((constituent_data.outlet_id = baseflow_data.outlet_id)
+                AND (constituent_data.datetime = baseflow_data.datetime)));""")
+    # ORDER BY
+    #     constituent_data.outlet_id,
+    #     constituent_data.datetime;
+    # 
+
 def create_constituent_summary_report(con: duckdb.DuckDBPyConnection):
     """
     Create a constituent summary report in the reports schema that groups observations by constituent and station.
@@ -66,11 +385,54 @@ def create_constituent_summary_report(con: duckdb.DuckDBPyConnection):
             FROM
             analytics.observations
             GROUP BY
-            constituent,station_id,station_origin
-            ORDER BY
-            constituent,sample_count;''')
+            constituent,station_id,station_origin;
+            ''')
+                
+            # ORDER BY
+            # constituent,sample_count;''')
+
+def create_outlet_summary_report(con: duckdb.DuckDBPyConnection):
+    con.execute("""
+        CREATE VIEW reports.outlet_constituent_summary AS
+    SELECT
+        outlet_id,
+        constituent,
+        count_star() AS sample_count,
+        avg("value") AS average_value,
+        min("value") AS min_value,
+        max("value") AS max_value,
+        "year"(min(datetime)) AS start_date,
+        "year"(max(datetime)) AS end_date
+    FROM
+        analytics.outlet_observations
+    GROUP BY
+        constituent,
+        outlet_id
+    """)
 
+    
+       
+def drop_station_id(con: duckdb.DuckDBPyConnection, station_id: str,station_origin: str):
+    """
+    Drop all data for a specific station from staging and analytics schemas.
+    """
+    con.execute(f"DELETE FROM staging.equis_raw WHERE station_id = '{station_id}' AND station_origin = '{station_origin}'")
+    con.execute(f"DELETE FROM staging.wiski_raw WHERE station_id = '{station_id}' AND station_origin = '{station_origin}'")
+    con.execute(f"DELETE FROM analytics.equis WHERE station_id = '{station_id}' AND station_origin = '{station_origin}'")
+    con.execute(f"DELETE FROM analytics.wiski WHERE station_id = '{station_id}' AND station_origin = '{station_origin}'")
+    update_views(con)
 
+def update_views(con: duckdb.DuckDBPyConnection):
+    """
+    Update all views in the database.
+    """
+    create_staging_qc_count_view(con)
+    create_combined_observations_view(con)
+    create_constituent_summary_report(con)
+    create_outlet_observations_view(con)
+    create_outlet_observations_with_flow_view(con)
+    create_outlet_summary_report(con)
+    
 def connect(db_path: str, read_only: bool = False) -> duckdb.DuckDBPyConnection:
     """
     Returns a DuckDB connection to the given database path.
@@ -106,6 +468,22 @@ def load_df_to_staging(con: duckdb.DuckDBPyConnection, df: pd.DataFrame, table_n
     con.execute(f"CREATE TABLE staging.{table_name} AS SELECT * FROM tmp_df")
     con.unregister("tmp_df")
 
+def add_df_to_staging(con: duckdb.DuckDBPyConnection, df: pd.DataFrame, table_name: str):
+    """
+    Append a pandas DataFrame into a staging table. This will create the staging
+    table if it does not exist.
+    """
+    # register pandas DF and create table if not exists
+    con.register("tmp_df", df)
+    con.execute(f"""
+        CREATE TABLE IF NOT EXISTS staging.{table_name} AS 
+        SELECT * FROM tmp_df
+    """)
+    con.execute(f"""
+        INSERT INTO staging.{table_name} 
+        SELECT * FROM tmp_df
+    """)
+    con.unregister("tmp_df")
 
 def load_csv_to_staging(con: duckdb.DuckDBPyConnection, csv_path: str, table_name: str, replace: bool = True, **read_csv_kwargs):
     """

mpcaHydro/warehouseManager.py

@@ -0,0 +1,47 @@
+
+import pandas as pd
+#from abc import abstractmethod
+from pathlib import Path
+from mpcaHydro import equis, wiski, warehouse
+import duckdb
+
+
+
+
+
+#%%
+'''
+This modules contains classes and functions to manage data downloads and storage into a local data warehouse.
+
+
+'''
+
+def get_db_path(warehouse_path:Path,db_name:str = 'observations')->Path:
+    '''
+    Constructs the full path to the database file within the warehouse directory.
+
+    Parameters:
+    warehouse_path (Path): The path to the warehouse directory.
+    db_name (str): The name of the database file.
+
+    Returns:
+    Path: The full path to the database file.
+    '''
+    return Path(warehouse_path) / db_name
+
+def construct_database(db_path:Path,db_name:str = 'observations')->Path:
+    '''
+    Constructs the full path to the database file within the warehouse directory.
+
+    Parameters:
+    warehouse_path (Path): The path to the warehouse directory.
+    db_name (str): The name of the database file.
+
+    Returns:
+    Path: The full path to the database file.
+    '''
+    db_path = Path(db_path) / db_name
+    warehouse.init_db(warehouse_path=db_path)
+
+
+

mpcaHydro/{WISKI.py → wiski.py}

@@ -157,7 +157,7 @@ def download_chunk(ts_id,start_year = 1996,end_year = 2030, interval = 4, as_jso
             end = end_year
         df = pywisk.get_ts(ts_id,start_date = f'{start}-01-01',end_date = f'{end}-12-31',as_json = as_json)
         if not df.empty: frames.append(df)
-        df.index = pd.to_datetime(df['Timestamp'])
+        df['Timestamp'] = pd.to_datetime(df['Timestamp']).dt.tz_localize(None)
         time.sleep(.1)   
     return pd.concat(frames)
 
@@ -197,11 +197,8 @@ def tkn(station_nos,start_year = 1996,end_year = 2030):
     return _download('TKN',station_nos,start_year,end_year)
 
 
-def filter_quality_codes(df):
-    '''
-    Filter dataframe by valid quality codes
-    '''
-    return df.loc[df['Quality Code'].isin(DATA_CODES)]
+
+
 
 def convert_units(df):
     '''
@@ -233,12 +230,22 @@ def normalize_columns(df):
         'station_no':'station_id',
         'Timestamp':'datetime',
         'Value':'value',
-        'ts_unitsymbol':'unit'}, inplace=True)
+        'ts_unitsymbol':'unit',
+        'Quality Code':'quality_code',
+        'Quality Code Name':'quality_code_name'}, inplace=True)
     return df
     
+
+
+def filter_quality_codes(df, data_codes):
+    '''
+    Filter dataframe by valid quality codes
+    '''
+    return df.loc[df['quality_code'].isin(data_codes)]
+
 def average_results(df):
-    df['datetime'] = pd.to_datetime(df.loc[:,'datetime'])
-    df['datetime'] = df['datetime'].dt.round('h')
+    #df['datetime'] = pd.to_datetime(df.loc[:,'datetime'])
+    df.loc[:,'datetime'] = df.loc[:,'datetime'].dt.round('h')
     return df.groupby(['station_id', 'datetime', 'constituent', 'unit']).agg(value=('value', 'mean')).reset_index()
     # Convert units
 
@@ -267,14 +274,35 @@ def calculate_baseflow(df, method = 'Boughton'):
     return pd.concat(dfs)
 
 
-def transform(df, baseflow_method = 'Boughton'):
+def normalize(df):
     '''
-    Transform raw WISKI data into standardized format
+    Standardize raw WISKI data into standardized format without transformations.
+    The standardized format includes normalized column names and units.
+    ---
+    Parameters:
+    df (pandas.DataFrame): Raw WISKI data
+    Returns:
+    pandas.DataFrame: Normalized WISKI data
     '''
-    df = filter_quality_codes(df)
+
     df = convert_units(df)
     df = normalize_columns(df)
+    return df
+
+def transform(df, filter_qc_codes = True, data_codes = None, baseflow_method = 'Boughton'):
+    '''
+    Transform normalized WISKI data into standardized format
+    '''
+    df = normalize(df)
+    if filter_qc_codes:
+        if data_codes is None:
+            data_codes = DATA_CODES
+        df = filter_quality_codes(df, data_codes)
     df = average_results(df)
     df = calculate_baseflow(df, method = baseflow_method)
     df['station_origin'] = 'wiski'
+    #df.set_index('datetime',inplace=True)
     return df
+
+
+

mpcaHydro/xref.py

@@ -0,0 +1,74 @@
+import pandas as pd
+from pathlib import Path
+
+WISKI_EQUIS_XREF = pd.read_csv(Path(__file__).parent/'data/WISKI_EQUIS_XREF.csv')
+#WISKI_EQUIS_XREF = pd.read_csv('C:/Users/mfratki/Documents/GitHub/hspf_tools/WISKI_EQUIS_XREF.csv')
+
+
+def are_lists_identical(nested_list):
+    # Sort each sublist
+    sorted_sublists = [sorted(sublist) for sublist in nested_list]
+    # Compare all sublists to the first one
+    return all(sublist == sorted_sublists[0] for sublist in sorted_sublists)                                                                                               
+
+def get_wiski_stations():
+    return list(WISKI_EQUIS_XREF['WISKI_STATION_NO'].unique())
+
+def get_equis_stations():
+    return list(WISKI_EQUIS_XREF['EQUIS_STATION_ID'].unique())
+
+def wiski_equis_alias(wiski_station_id):
+    equis_ids =  list(set(WISKI_EQUIS_XREF.loc[WISKI_EQUIS_XREF['WISKI_STATION_NO'] == wiski_station_id,'WISKI_EQUIS_ID'].to_list()))
+    equis_ids = [equis_id for equis_id in equis_ids if not pd.isna(equis_id)]
+    if len(equis_ids) == 0:
+        return []
+    elif len(equis_ids) > 1:
+        print(f'Too Many Equis Stations for {wiski_station_id}')
+        raise 
+    else:
+        return equis_ids[0]
+
+def wiski_equis_associations(wiski_station_id):
+    equis_ids =  list(WISKI_EQUIS_XREF.loc[WISKI_EQUIS_XREF['WISKI_STATION_NO'] == wiski_station_id,'EQUIS_STATION_ID'].unique())
+    equis_ids =  [equis_id for equis_id in equis_ids if not pd.isna(equis_id)]
+    if len(equis_ids) == 0:
+        return []
+    else:
+        return equis_ids
+    
+def equis_wiski_associations(equis_station_id):
+    wiski_ids = list(WISKI_EQUIS_XREF.loc[WISKI_EQUIS_XREF['EQUIS_STATION_ID'] == equis_station_id,'WISKI_STATION_NO'].unique())
+    wiski_ids = [wiski_id for wiski_id in wiski_ids if not pd.isna(wiski_id)]
+    if len(wiski_ids) == 0:
+        return []
+    else:
+        return wiski_ids
+    
+def equis_wiski_alias(equis_station_id):
+    wiski_ids =  list(set(WISKI_EQUIS_XREF.loc[WISKI_EQUIS_XREF['WISKI_EQUIS_ID'] == equis_station_id,'WISKI_STATION_NO'].to_list()))
+    wiski_ids = [wiski_id for wiski_id in wiski_ids if not pd.isna(wiski_id)]
+    if len(wiski_ids) == 0:
+        return []
+    elif len(wiski_ids) > 1:
+        print(f'Too Many WISKI Stations for {equis_station_id}')
+        raise ValueError(f'Too Many WISKI Stations for {equis_station_id}')
+    else:
+        return wiski_ids[0]
+
+def _equis_wiski_associations(equis_station_ids):
+    wiski_stations = [equis_wiski_associations(equis_station_id) for equis_station_id in equis_station_ids]
+    if are_lists_identical(wiski_stations):
+        return wiski_stations[0]
+    else:
+        return []
+        
+def _stations_by_wid(wid_no,station_origin):
+    if station_origin in ['wiski','wplmn']:
+        station_col = 'WISKI_STATION_NO'
+    elif station_origin in ['equis','swd']:
+        station_col = 'EQUIS_STATION_ID'
+    else:
+        raise
+        
+    return list(WISKI_EQUIS_XREF.loc[WISKI_EQUIS_XREF['WID'] == wid_no,station_col].unique())
+

{mpcahydro-2.1.0.dist-info → mpcahydro-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpcaHydro
-Version: 2.1.0
+Version: 2.2.0
 Summary: Python package for downloading MPCA hydrology data
 Project-URL: Homepage, https://github.com/mfratkin1/mpcaHydro
 Author-email: Mulu Fratkin <michael.fratkin@state.mn.us>
@@ -10,7 +10,9 @@ Keywords: Hydrology,MPCA
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Requires-Python: >=3.8
+Requires-Dist: baseflow
 Requires-Dist: duckdb
+Requires-Dist: oracledb
 Requires-Dist: pandas
 Requires-Dist: pathlib
 Requires-Dist: requests