ecopipeline 1.0.5__py3-none-any.whl → 1.1.1__py3-none-any.whl

ecopipeline/load/__init__.py

@@ -1,3 +1,3 @@
-from .load import check_table_exists, create_new_table, load_overwrite_database, load_event_table, report_data_loss, load_data_statistics
+from .load import check_table_exists, create_new_table, load_overwrite_database, load_event_table, report_data_loss, load_data_statistics, load_alarms
 __all__ = ["check_table_exists", "create_new_table", "load_overwrite_database", "load_event_table", "report_data_loss",
-           "load_data_statistics"]
+           "load_data_statistics", "load_alarms"]

ecopipeline/load/load.py

@@ -302,6 +302,14 @@ def load_event_table(config : ConfigManager, event_df: pd.DataFrame, site_name :
     bool: 
         A boolean value indicating if the data was successfully written to the database. 
     """
+    if event_df.empty:
+        print("No events to load. DataFrame is empty.")
+        return True
+    if site_name is None:
+        site_name = config.get_site_name()
+    if 'alarm_type' in event_df.columns:
+        print("Alarm dataframe detected... redirecting dataframe to load_alarms() function...")
+        return load_alarms(config, event_df, site_name)
     # define constants
     proj_cop_filters = ['MV_COMMISSIONED','PLANT_COMMISSIONED','DATA_LOSS_COP','SYSTEM_MAINTENANCE','SYSTEM_TESTING']
     optim_cop_filters = ['MV_COMMISSIONED','PLANT_COMMISSIONED','DATA_LOSS_COP','INSTALLATION_ERROR_COP',
@@ -320,8 +328,6 @@ def load_event_table(config : ConfigManager, event_df: pd.DataFrame, site_name :
     print(f"Attempting to write data for {event_df.index[0]} to {event_df.index[-1]} into {table_name}")
     
     # Get string of all column names for sql insert
-    if site_name is None:
-        site_name = config.get_site_name()
     column_names = f"start_time_pt,site_name"
     column_types = ["datetime","varchar(25)","datetime",
                     "ENUM('MISC_EVENT','DATA_LOSS','DATA_LOSS_COP','SITE_VISIT','SYSTEM_MAINTENANCE','EQUIPMENT_MALFUNCTION','PARTIAL_OCCUPANCY','INSTALLATION_ERROR','ALARM','SILENT_ALARM','MV_COMMISSIONED','PLANT_COMMISSIONED','INSTALLATION_ERROR_COP','SOO_PERIOD','SOO_PERIOD_COP','SYSTEM_TESTING')",
@@ -543,4 +549,299 @@ def _generate_mysql_update(row, index, table_name, primary_key):
     else:
         statement = ""
 
-    return statement, values
+    return statement, values
+
+
+def load_alarms(config: ConfigManager, alarm_df: pd.DataFrame, site_name: str = None) -> bool:
+    """
+    Loads alarm data from central_alarm_df_creator() output into the alarm and alarm_inst tables.
+
+    For each alarm instance in the DataFrame:
+    - Checks if a matching alarm record exists (same site_name, alarm_type, variable_name)
+    - If no matching alarm exists, creates a new record in the alarm table
+    - Inserts the alarm instance (with start/end times and certainty) into the alarm_inst table
+
+    Certainty-based overlap handling for alarm instances:
+    - If new alarm has higher certainty than existing overlapping instance: existing is split
+      around the new alarm so each time segment has the highest certainty available
+    - If new alarm has lower certainty than existing: only non-overlapping portions of new
+      alarm are inserted
+    - If same certainty: existing instance is extended to encompass both time periods
+
+    Parameters
+    ----------
+    config : ecopipeline.ConfigManager
+        The ConfigManager object that holds configuration data for the pipeline.
+    alarm_df : pd.DataFrame
+        The pandas DataFrame output from central_alarm_df_creator(). Must have columns:
+        start_time_pt, end_time_pt, alarm_type, variable_name. Optional column: certainty
+        (defaults to 3 if not present). Certainty values: 3=high, 2=med, 1=low.
+    site_name : str
+        The name of the site to associate alarms with. If None, defaults to config.get_site_name()
+
+    Returns
+    -------
+    bool:
+        A boolean value indicating if the data was successfully written to the database.
+    """
+    if alarm_df.empty:
+        print("No alarms to load. DataFrame is empty.")
+        return True
+
+    # Validate required columns
+    required_columns = ['start_time_pt', 'end_time_pt', 'alarm_type', 'variable_name']
+    missing_columns = [col for col in required_columns if col not in alarm_df.columns]
+    if missing_columns:
+        raise Exception(f"alarm_df is missing required columns: {missing_columns}")
+
+    # Sort by start_time_pt to process alarms in chronological order
+    alarm_df = alarm_df.sort_values(by='start_time_pt').reset_index(drop=True)
+
+    if site_name is None:
+        site_name = config.get_site_name()
+
+    dbname = config.get_db_name()
+    alarm_table = "alarm"
+    alarm_inst_table = "alarm_inst"
+
+    connection, cursor = config.connect_db()
+
+    try:
+        # Check if tables exist
+        if not check_table_exists(cursor, alarm_table, dbname):
+            create_table_statement = """
+                CREATE TABLE alarm (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    var_names_id VARCHAR(40),
+                    start_time_pt DATETIME NOT NULL,
+                    end_time_pt DATETIME NULL,
+                    site_name VARCHAR(20),
+                    alarm_type VARCHAR(20),
+                    variable_name VARCHAR(70),
+                    silenced BOOLEAN,
+                    closing_event_id INT NULL,
+                    FOREIGN KEY (closing_event_id) REFERENCES site_events(id),
+                    UNIQUE INDEX unique_alarm (site_name, alarm_type, variable_name, start_time_pt, end_time_pt)
+                );
+                """
+            cursor.execute(create_table_statement)
+        if not check_table_exists(cursor, alarm_inst_table, dbname):
+            create_table_statement = """
+            CREATE TABLE alarm_inst (
+                inst_id INT AUTO_INCREMENT PRIMARY KEY,
+                id INT,
+                start_time_pt DATETIME NOT NULL,
+                end_time_pt DATETIME NOT NULL,
+                certainty INT NOT NULL,
+                FOREIGN KEY (id) REFERENCES alarm(id)
+            );
+            """
+            cursor.execute(create_table_statement)
+
+        # Get existing alarms for this site
+        cursor.execute(
+            f"SELECT id, alarm_type, variable_name, start_time_pt, end_time_pt FROM {alarm_table} WHERE site_name = %s",
+            (site_name,)
+        )
+        existing_alarms = cursor.fetchall()
+        # Create lookup dict: (alarm_type, variable_name) -> list of (alarm_id, start_time, end_time)
+        # Using a list because there can be multiple alarms with same type/variable but different date ranges
+        alarm_lookup = {}
+        for row in existing_alarms:
+            key = (row[1], row[2])  # (alarm_type, variable_name)
+            if key not in alarm_lookup:
+                alarm_lookup[key] = []
+            alarm_lookup[key].append({
+                'id': row[0],
+                'start_time': row[3],
+                'end_time': row[4]
+            })
+
+        # SQL statements
+        insert_alarm_sql = f"""
+            INSERT INTO {alarm_table} (var_names_id, start_time_pt, end_time_pt, site_name, alarm_type, variable_name, silenced)
+            VALUES (%s, %s, %s, %s, %s, %s, %s)
+        """
+        update_alarm_dates_sql = f"""
+            UPDATE {alarm_table} SET start_time_pt = %s, end_time_pt = %s WHERE id = %s
+        """
+        insert_inst_sql = f"""
+            INSERT INTO {alarm_inst_table} (id, start_time_pt, end_time_pt, certainty)
+            VALUES (%s, %s, %s, %s)
+        """
+        update_inst_sql = f"""
+            UPDATE {alarm_inst_table} SET start_time_pt = %s, end_time_pt = %s WHERE inst_id = %s
+        """
+        delete_inst_sql = f"""
+            DELETE FROM {alarm_inst_table} WHERE inst_id = %s
+        """
+
+        new_alarms = 0
+        updated_alarms = 0
+        new_instances = 0
+        updated_instances = 0
+        max_gap_days = 3
+
+        for _, row in alarm_df.iterrows():
+            start_time = row['start_time_pt']
+            end_time = row['end_time_pt']
+            alarm_type = row['alarm_type']
+            variable_name = row['variable_name']
+            certainty = row.get('certainty', 3)  # Default to high certainty if not specified
+
+            lookup_key = (alarm_type, variable_name)
+            alarm_id = None
+
+            if lookup_key in alarm_lookup:
+                # Find matching alarm based on date range logic
+                for alarm_record in alarm_lookup[lookup_key]:
+                    alarm_start = alarm_record['start_time']
+                    alarm_end = alarm_record['end_time']
+
+                    # Case 1: Alarm dates encapsulate row dates - just use this alarm
+                    if alarm_start <= start_time and alarm_end >= end_time:
+                        alarm_id = alarm_record['id']
+                        break
+
+                    # Calculate gap between date ranges
+                    if end_time < alarm_start:
+                        gap = (alarm_start - end_time).days
+                    elif start_time > alarm_end:
+                        gap = (start_time - alarm_end).days
+                    else:
+                        gap = 0  # Overlapping
+
+                    # Case 2: Overlapping or within 3 days - extend the alarm dates
+                    if gap <= max_gap_days:
+                        alarm_id = alarm_record['id']
+                        new_start = min(alarm_start, start_time)
+                        new_end = max(alarm_end, end_time)
+
+                        # Only update if dates actually changed
+                        if new_start != alarm_start or new_end != alarm_end:
+                            cursor.execute(update_alarm_dates_sql, (new_start, new_end, alarm_id))
+                            # Update the lookup cache
+                            alarm_record['start_time'] = new_start
+                            alarm_record['end_time'] = new_end
+                            updated_alarms += 1
+                        break
+
+                # Case 3: No matching alarm found (gap > 3 days for all existing alarms)
+                # Will create a new alarm below
+
+            if alarm_id is None:
+                # Create new alarm record
+                cursor.execute(insert_alarm_sql, (
+                    "No ID",  # TODO add actual ID?
+                    start_time,
+                    end_time,
+                    site_name,
+                    alarm_type,
+                    variable_name,
+                    False  # silenced = False by default
+                ))
+                # Retrieve the ID from database to handle concurrent inserts safely
+                cursor.execute(
+                    f"""SELECT id FROM {alarm_table}
+                        WHERE site_name = %s AND alarm_type = %s AND variable_name = %s
+                        AND start_time_pt = %s AND end_time_pt = %s""",
+                    (site_name, alarm_type, variable_name, start_time, end_time)
+                )
+                result = cursor.fetchone()
+                if result is None:
+                    raise Exception(f"Failed to retrieve alarm ID after insert for {alarm_type}/{variable_name}")
+                alarm_id = result[0]
+                # Add to lookup cache
+                if lookup_key not in alarm_lookup:
+                    alarm_lookup[lookup_key] = []
+                alarm_lookup[lookup_key].append({
+                    'id': alarm_id,
+                    'start_time': start_time,
+                    'end_time': end_time
+                })
+                new_alarms += 1
+
+            # Get existing alarm instances for this alarm_id that might overlap
+            cursor.execute(
+                f"""SELECT inst_id, start_time_pt, end_time_pt, certainty
+                    FROM {alarm_inst_table}
+                    WHERE id = %s AND start_time_pt <= %s AND end_time_pt >= %s""",
+                (alarm_id, end_time, start_time)
+            )
+            existing_instances = cursor.fetchall()
+
+            # Track segments of the new alarm to insert (may be split by higher-certainty existing alarms)
+            new_segments = [(start_time, end_time, certainty)]
+
+            for existing in existing_instances:
+                existing_inst_id, existing_start, existing_end, existing_certainty = existing
+
+                # Process each new segment against this existing instance
+                updated_segments = []
+                for seg_start, seg_end, seg_certainty in new_segments:
+                    # Check if there's overlap
+                    if seg_end <= existing_start or seg_start >= existing_end:
+                        # No overlap, keep segment as is
+                        updated_segments.append((seg_start, seg_end, seg_certainty))
+                        continue
+
+                    # There is overlap - handle based on certainty comparison
+                    if existing_certainty < seg_certainty:
+                        # Case 1: New alarm has higher certainty - split existing around new
+                        # Part before new alarm (if any)
+                        if existing_start < seg_start:
+                            cursor.execute(update_inst_sql, (existing_start, seg_start, existing_inst_id))
+                            updated_instances += 1
+                            # Insert the part after new alarm (if any)
+                            if existing_end > seg_end:
+                                cursor.execute(insert_inst_sql, (alarm_id, seg_end, existing_end, existing_certainty))
+                                new_instances += 1
+                        elif existing_end > seg_end:
+                            # No part before, but there's a part after
+                            cursor.execute(update_inst_sql, (seg_end, existing_end, existing_inst_id))
+                            updated_instances += 1
+                        else:
+                            # Existing is completely encompassed by new - delete it
+                            cursor.execute(delete_inst_sql, (existing_inst_id,))
+                        # Keep the new segment as is
+                        updated_segments.append((seg_start, seg_end, seg_certainty))
+
+                    elif existing_certainty > seg_certainty:
+                        # Case 2: Existing has higher certainty - trim new segment to non-overlapping parts
+                        # Part before existing (if any)
+                        if seg_start < existing_start:
+                            updated_segments.append((seg_start, existing_start, seg_certainty))
+                        # Part after existing (if any)
+                        if seg_end > existing_end:
+                            updated_segments.append((existing_end, seg_end, seg_certainty))
+                        # The overlapping part of new segment is discarded
+
+                    else:
+                        # Case 3: Same certainty - merge to encompass both
+                        merged_start = min(seg_start, existing_start)
+                        merged_end = max(seg_end, existing_end)
+                        cursor.execute(update_inst_sql, (merged_start, merged_end, existing_inst_id))
+                        updated_instances += 1
+                        # Remove this segment from new_segments (it's been merged into existing)
+                        # Don't add to updated_segments
+
+                new_segments = updated_segments
+
+            # Insert any remaining new segments
+            for seg_start, seg_end, seg_certainty in new_segments:
+                if seg_start < seg_end:  # Only insert valid segments
+                    cursor.execute(insert_inst_sql, (alarm_id, seg_start, seg_end, seg_certainty))
+                    new_instances += 1
+
+        connection.commit()
+        print(f"Successfully loaded alarms: {new_alarms} new alarm records, {updated_alarms} updated alarm records, {new_instances} new instances, {updated_instances} updated instances.")
+        return True
+
+    except Exception as e:
+        print(f"Error loading alarms: {e}")
+        connection.rollback()
+        return False
+
+    finally:
+        cursor.close()
+        connection.close()

ecopipeline/utils/ConfigManager.py

@@ -222,6 +222,36 @@ class ConfigManager:
         print(f"Successfully connected to database.")
         return connection, connection.cursor()
     
+    def connect_siteConfig_db(self) -> (mysql.connector.MySQLConnection, mysql.connector.cursor.MySQLCursor):
+        """
+        Create a connection with the mySQL server. 
+
+        Parameters
+        ----------  
+        None
+
+        Returns
+        ------- 
+        mysql.connector.MySQLConnection, mysql.connector.cursor.MySQLCursor: 
+            A connection and cursor object. THe cursor can be used to execute
+            mySQL queries and the connection object can be used to save those changes. 
+        """
+
+        connection = None
+        try:
+            connection = mysql.connector.connect(
+                host=self.db_connection_info['host'],
+                user=self.db_connection_info['user'],
+                password=self.db_connection_info['password'],
+                database="SiteConfig"
+            )
+        except mysql.connector.Error:
+            print("Unable to connect to database with given credentials.")
+            return None, None
+
+        print(f"Successfully connected to database.")
+        return connection, connection.cursor()
+    
     def get_fm_token(self) -> str:
         # for getting feild manager api token
         if self.api_usr is None or self.api_pw is None:

{ecopipeline-1.0.5.dist-info → ecopipeline-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecopipeline
-Version: 1.0.5
+Version: 1.1.1
 Summary: Contains functions for use in Ecotope Datapipelines
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License (GPL)

ecopipeline-1.1.1.dist-info/RECORD

@@ -0,0 +1,42 @@
+ecopipeline/__init__.py,sha256=pjC00JWsjVAhS0jUKHD-wyi4UIpTsWbIg9JaxLS1mlc,275
+ecopipeline/event_tracking/Alarm.py,sha256=R8xlBieQIsORjEP_CdC_RW7vlq1XbGIpGnrpEyJNo64,15661
+ecopipeline/event_tracking/__init__.py,sha256=QT49yHZMw7L4zFw-paN0TVTKTOGeH_6-WjbuqebcD-4,1215
+ecopipeline/event_tracking/event_tracking.py,sha256=fJizghOnyhSne5uHDxR9Up67Qx0LUFik53LS_DQeriM,44261
+ecopipeline/event_tracking/alarms/AbnormalCOP.py,sha256=VeTLt7Fyr3GPflM2K0yLzKapW0gVnTePZaljV526HP4,4587
+ecopipeline/event_tracking/alarms/BackupUse.py,sha256=LrUq5R9Pyklh4yyuBsGjiPJwRsTWACbIXsMJI5rTx8k,5526
+ecopipeline/event_tracking/alarms/BalancingValve.py,sha256=z3NanIgjRIfqujnfUZFoeqNu0FrHU0qjnTRMkCKdfgs,4662
+ecopipeline/event_tracking/alarms/BlownFuse.py,sha256=0toXQ1Q5lQuw6I7Fm-yHUtcCrwXWJnDerVm8Dht21z4,4465
+ecopipeline/event_tracking/alarms/Boundary.py,sha256=07tGsf4tMFaS_WgclDX8XI7wH8bZm5-yyG8QBChvxC8,5121
+ecopipeline/event_tracking/alarms/HPWHInlet.py,sha256=wF3fzTqABJ7QMrdKODVlGHwCEB3Hj3njaaAKhQItYe4,4359
+ecopipeline/event_tracking/alarms/HPWHOutage.py,sha256=E2p5xJuJrpTXp8bJNM5Z4Qou5whtGwLEzPBdIBUpRsc,6045
+ecopipeline/event_tracking/alarms/HPWHOutlet.py,sha256=hQTSoykL9tsfby_prmty5xSxw2O2qri4vfbvSi_ny5w,5247
+ecopipeline/event_tracking/alarms/LSInconsist.py,sha256=9gPFhw5DT89tpu4MIXuJ2MbKu20wAlUVYFD9a32Eqrk,5748
+ecopipeline/event_tracking/alarms/PowerRatio.py,sha256=1PUFKimzCJ7PqbtzkMUe8imlGbkBX8tM9L7qpGMhyhM,5652
+ecopipeline/event_tracking/alarms/SOOChange.py,sha256=UJFoMTM0GSgcVSJcxZhmKu67RkFcaSmHIKvFlxxkblc,8092
+ecopipeline/event_tracking/alarms/ShortCycle.py,sha256=5dlBE-QrEdU20DDl6CUFIB86aojPNfEeNwiQTbd6XXY,3215
+ecopipeline/event_tracking/alarms/TMSetpoint.py,sha256=C7bhkJrHpJ7ENjGw1Y-r4VIhTeiIJC1yoQmw2KUrQDc,8624
+ecopipeline/event_tracking/alarms/TempRange.py,sha256=veMQ14Hm-Toom5wsJNe49DwPFS5MZMWp-dMTglUfAb0,5090
+ecopipeline/event_tracking/alarms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ecopipeline/extract/__init__.py,sha256=tGMph8ExJG_fYdGnlVbKfGwv8b4t8d7dcH2hekscpeg,822
+ecopipeline/extract/extract.py,sha256=JAWCfyWet1uo5uf8DL-GtWU5ijCWi7AUt4TxNKH4pFs,64653
+ecopipeline/extract/zip_to_lat_long.csv,sha256=rQpdyZxui34nNV-lLhjtbYkYrTz_IZzs9WSm7IjMMPY,2585933
+ecopipeline/load/__init__.py,sha256=1D1BPhYzfGeHzE5dDtinGi3M7SFr9IfkSulHJKubM58,320
+ecopipeline/load/load.py,sha256=uQ4nnnui3WmXFGqxI7Me1HPxdLsNybHMbbqkr_oiqHQ,38762
+ecopipeline/transform/__init__.py,sha256=FjGcNpYNEYPdYQhogNRrQlKH2hGNNLv55jig1KaGaHY,2686
+ecopipeline/transform/bayview.py,sha256=TP24dnTsUD95X-f6732egPZKjepFLJgDm9ImGr-fppY,17899
+ecopipeline/transform/lbnl.py,sha256=EQ54G4rJXaZ7pwVusKcdK2KBehSdCsNo2ybphtMGs7o,33400
+ecopipeline/transform/transform.py,sha256=KVj3kkDa_dQOqRU4l4cHK01L0UPv3FTusQ_Dk2ez8RA,57270
+ecopipeline/utils/ConfigManager.py,sha256=GJxUQ9psm_uiU3j0LBsn7h0OFGvxHWS8dAomkaTLR3A,14960
+ecopipeline/utils/NOAADataDownloader.py,sha256=iC2nl_O4PS1KFrchcPXRZxshwZwUMSqXy6BQBUwnOUU,20927
+ecopipeline/utils/__init__.py,sha256=7dT3tP6SMK4uBW6NBmQ8i6LaNTTuV6fpAZToBBlJ904,62
+ecopipeline/utils/unit_convert.py,sha256=VFh1we2Y8KV3u21BeWb-U3TlZJXo83q5vdxxkpgcuME,3064
+ecopipeline/utils/pkls/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ecopipeline/utils/pkls/tasseron_resistance_to_temp_3.pkl,sha256=9UpCZ3rSu0mU4LoTBg2M6Q-t7aGLaejEcAo801vfr7U,2013
+ecopipeline/utils/pkls/tasseron_temp_to_resistance_2.pkl,sha256=Uq6I2dl5GcR5wb5QxurgDP4A2D4-N3neDL3BKtx53A4,2047
+ecopipeline/utils/pkls/veris_resistance_to_temp_3.pkl,sha256=CVbUWJvOQXg2nZ-0GP9FWtU-ffMGcwg3ok5q669bmf8,1472
+ecopipeline/utils/pkls/veris_temp_to_resistance_2.pkl,sha256=JiEp4SxR9eq-olKd8TKAG37iHMscJE_2SSHizGqBdno,1472
+ecopipeline-1.1.1.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ecopipeline-1.1.1.dist-info/METADATA,sha256=k1RWYAYwxdQaTYlD70WJcE6g-6Arqv9JAiziTKzn-Bg,2363
+ecopipeline-1.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ecopipeline-1.1.1.dist-info/top_level.txt,sha256=WOPFJH2LIgKqm4lk2OnFF5cgVkYibkaBxIxgvLgO7y0,12
+ecopipeline-1.1.1.dist-info/RECORD,,

{ecopipeline-1.0.5.dist-info → ecopipeline-1.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ecopipeline-1.0.5.dist-info/RECORD

@@ -1,25 +0,0 @@
-ecopipeline/__init__.py,sha256=pjC00JWsjVAhS0jUKHD-wyi4UIpTsWbIg9JaxLS1mlc,275
-ecopipeline/event_tracking/__init__.py,sha256=91KN-WmYN6q1WbTJO-EE9QQUPCAQ1AbqH7krRsqaAug,402
-ecopipeline/event_tracking/event_tracking.py,sha256=TNuCNcr-5z9hEfu5CXyoMDvDyeBT05KB2X1U5PBtxeg,101489
-ecopipeline/extract/__init__.py,sha256=tGMph8ExJG_fYdGnlVbKfGwv8b4t8d7dcH2hekscpeg,822
-ecopipeline/extract/extract.py,sha256=OeNwxJ9uWZLJjtpm9_qzVpRRaqyPKjn39WlW4SpzDYE,62062
-ecopipeline/load/__init__.py,sha256=NLa_efQJZ8aP-J0Y5xx9DP7mtfRH9jY6Jz1ZMZN_BAA,292
-ecopipeline/load/load.py,sha256=PaSGWOZI0Xg44_SWN7htn2DPIAU_s8mOtCGibXq25tM,24614
-ecopipeline/transform/__init__.py,sha256=FjGcNpYNEYPdYQhogNRrQlKH2hGNNLv55jig1KaGaHY,2686
-ecopipeline/transform/bayview.py,sha256=TP24dnTsUD95X-f6732egPZKjepFLJgDm9ImGr-fppY,17899
-ecopipeline/transform/lbnl.py,sha256=EQ54G4rJXaZ7pwVusKcdK2KBehSdCsNo2ybphtMGs7o,33400
-ecopipeline/transform/transform.py,sha256=KVj3kkDa_dQOqRU4l4cHK01L0UPv3FTusQ_Dk2ez8RA,57270
-ecopipeline/utils/ConfigManager.py,sha256=E3YzdolFcRMVwxNk359Y0XVShqYquQ9otizPkkk9FU8,13880
-ecopipeline/utils/NOAADataDownloader.py,sha256=iC2nl_O4PS1KFrchcPXRZxshwZwUMSqXy6BQBUwnOUU,20927
-ecopipeline/utils/__init__.py,sha256=7dT3tP6SMK4uBW6NBmQ8i6LaNTTuV6fpAZToBBlJ904,62
-ecopipeline/utils/unit_convert.py,sha256=VFh1we2Y8KV3u21BeWb-U3TlZJXo83q5vdxxkpgcuME,3064
-ecopipeline/utils/pkls/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ecopipeline/utils/pkls/tasseron_resistance_to_temp_3.pkl,sha256=9UpCZ3rSu0mU4LoTBg2M6Q-t7aGLaejEcAo801vfr7U,2013
-ecopipeline/utils/pkls/tasseron_temp_to_resistance_2.pkl,sha256=Uq6I2dl5GcR5wb5QxurgDP4A2D4-N3neDL3BKtx53A4,2047
-ecopipeline/utils/pkls/veris_resistance_to_temp_3.pkl,sha256=CVbUWJvOQXg2nZ-0GP9FWtU-ffMGcwg3ok5q669bmf8,1472
-ecopipeline/utils/pkls/veris_temp_to_resistance_2.pkl,sha256=JiEp4SxR9eq-olKd8TKAG37iHMscJE_2SSHizGqBdno,1472
-ecopipeline-1.0.5.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ecopipeline-1.0.5.dist-info/METADATA,sha256=eU8B5fLOWV_TQimqs2Ws-PgTZt88XRy8xgAmh9Dn5OQ,2363
-ecopipeline-1.0.5.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-ecopipeline-1.0.5.dist-info/top_level.txt,sha256=WOPFJH2LIgKqm4lk2OnFF5cgVkYibkaBxIxgvLgO7y0,12
-ecopipeline-1.0.5.dist-info/RECORD,,