ecopipeline 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

ecopipeline/extract/__init__.py

@@ -1,4 +1,4 @@
-from .extract import get_noaa_data, json_to_df, extract_files, get_last_full_day_from_db, get_db_row_from_time, extract_new, csv_to_df, get_sub_dirs, msa_to_df, fm_api_to_df, small_planet_control_to_df, dent_csv_to_df, flow_csv_to_df, pull_egauge_data, egauge_csv_to_df, remove_char_sequence_from_csv_header, tb_api_to_df, skycentrics_api_to_df,get_OAT_open_meteo
+from .extract import get_noaa_data, json_to_df, extract_files, get_last_full_day_from_db, get_db_row_from_time, extract_new, csv_to_df, get_sub_dirs, msa_to_df, fm_api_to_df, small_planet_control_to_df, dent_csv_to_df, flow_csv_to_df, pull_egauge_data, egauge_csv_to_df, remove_char_sequence_from_csv_header, tb_api_to_df, skycentrics_api_to_df,get_OAT_open_meteo, licor_cloud_api_to_df
 __all__ = ["get_noaa_data", "json_to_df", "extract_files", "get_last_full_day_from_db", "get_db_row_from_time", 'extract_new', "csv_to_df", "get_sub_dirs", "msa_to_df", "fm_api_to_df",
            "small_planet_control_to_df","dent_csv_to_df","flow_csv_to_df","pull_egauge_data", "egauge_csv_to_df","remove_char_sequence_from_csv_header", "tb_api_to_df", "skycentrics_api_to_df",
-           "get_OAT_open_meteo"]
+           "get_OAT_open_meteo","licor_cloud_api_to_df"]

ecopipeline/extract/extract.py

@@ -862,6 +862,90 @@ def pull_egauge_data(config: ConfigManager, eGauge_ids: list, eGauge_usr : str,
 
     os.chdir(original_directory)
 
+def licor_cloud_api_to_df(config: ConfigManager, startTime: datetime = None, endTime: datetime = None, create_csv : bool = True) -> pd.DataFrame:
+    """
+    Connects to the LI-COR Cloud API to pull sensor data and returns a dataframe.
+
+    The function queries the LI-COR Cloud API for sensor data within the specified time range.
+    Each sensor's data is returned as a separate column in the dataframe, indexed by timestamp.
+
+    Parameters
+    ----------
+    config : ecopipeline.ConfigManager
+        The ConfigManager object that holds configuration data for the pipeline. The config manager
+        must contain the api_token and api_device_id (device serial number) for authentication
+        with the LI-COR Cloud API.
+    startTime : datetime
+        The start time for data extraction. If None, defaults to 28 hours before endTime.
+    endTime : datetime
+        The end time for data extraction. If None, defaults to the current time.
+    create_csv : bool
+        If True, saves the extracted data to a CSV file in the data directory (default True).
+
+    Returns
+    -------
+    pd.DataFrame:
+        Pandas DataFrame with sensor serial numbers as column headers and timestamps as the index.
+        The index is in UTC and may need to be converted to the appropriate timezone.
+        Returns an empty DataFrame if the API call fails.
+    """
+    df = pd.DataFrame()
+    api_device_id = config.api_device_id
+    if endTime is None:
+        endTime = datetime.now()
+    if startTime is None:
+        # 28 hours to ensure encapsulation of last day
+        startTime = endTime - timedelta(hours=28)
+
+    url = f'https://api.licor.cloud/v2/data'
+    token = config.api_token
+    params = {
+        'deviceSerialNumber': api_device_id,
+        'startTime': f'{int(startTime.timestamp())*1000}',
+        'endTime': f'{int(endTime.timestamp())*1000}'
+    }
+    # Headers
+    headers = {
+        'accept': 'application/json',
+        'Authorization': f'Bearer {token}'
+    }
+
+    try:
+        response = requests.get(url, headers=headers, params=params)
+        if response.status_code == 200:
+            response_json = response.json()
+            data = {}
+            if 'sensors' in response_json.keys():
+                for sensor in response_json['sensors']:
+                    sensor_id = sensor['sensorSerialNumber']
+                    for measurement in sensor.get('data', []):
+                        try:
+                            records = measurement.get('records', [])
+                            series = pd.Series(
+                                data={record[0]: _get_float_value(record[1]) for record in records}
+                            )
+                            data[sensor_id] = series
+                        except:
+                            print(f"Could not convert {sensor_id} values to floats.")
+            df = pd.DataFrame(data)
+            df.index = pd.to_datetime(df.index, unit='ms')
+            df = df.sort_index()
+        else:
+            print(f"Failed to make GET request. Status code: {response.status_code} {response.json()}")
+            df = pd.DataFrame()
+    except Exception as e:
+        traceback.print_exc()
+        print(f"An error occurred: {e}")
+        df = pd.DataFrame()
+    # save to file
+    if create_csv:
+        filename = f"{startTime.strftime('%Y%m%d%H%M%S')}.csv"
+        original_directory = os.getcwd()
+        os.chdir(config.data_directory)
+        df.to_csv(filename, index_label='time_pt')
+        os.chdir(original_directory)
+    return df
+
 def tb_api_to_df(config: ConfigManager, startTime: datetime = None, endTime: datetime = None, create_csv : bool = True, query_hours : float = 1,
                  sensor_keys : list = [], seperate_keys : bool = False, device_id_overwrite : str = None, csv_prefix : str = ""):
     """

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/transform/transform.py

@@ -352,7 +352,7 @@ def convert_temp_resistance_type(df : pd.DataFrame, column_name : str, sensor_mo
     return df
 
 def estimate_power(df : pd.DataFrame, new_power_column : str, current_a_column : str, current_b_column : str, current_c_column : str,
-                 assumed_voltage : float = 208, power_factor : float = 1):
+                 assumed_voltage : float = 208, power_factor : float = 1) -> pd.DataFrame:
     """
     df: pd.DataFrame
         Pandas dataframe with minute-to-minute data

ecopipeline/utils/ConfigManager.py

@@ -7,6 +7,7 @@ from datetime import datetime
 import base64
 import hashlib
 import hmac
+import pandas as pd
 
 class ConfigManager:
     """
@@ -79,9 +80,10 @@ class ConfigManager:
                     self.api_pw = configure.get('data', 'api_pw')
                     self.api_device_id = configure.get('data','device_id')
                     configured_data_method = True
-                elif 'api_token' in configure['data'] and 'api_secret' in configure['data']:
+                elif 'api_token' in configure['data']:
                     self.api_token = configure.get('data', 'api_token')
-                    self.api_secret = configure.get('data', 'api_secret')
+                    if 'api_secret' in configure['data']:
+                        self.api_secret = configure.get('data', 'api_secret')
                     self.api_device_id = configure.get('data','device_id')
                     configured_data_method = True
             if not configured_data_method:
@@ -281,3 +283,14 @@ class ConfigManager:
             hashlib.sha1).digest())
         token = '{}:{}'.format(self.api_token, signature.decode())
         return token, date_str
+    
+    def get_ls_df(self, ls_file_name : str = 'load_shift.csv') -> pd.DataFrame:
+        full_ls_filename = f"{self.input_directory}load_shift.csv" 
+        if ls_file_name != "" and os.path.exists(full_ls_filename):
+            ls_df = pd.read_csv(full_ls_filename)
+            ls_df['startDateTime'] = pd.to_datetime(ls_df['date'] + ' ' + ls_df['startTime'])
+            ls_df['endDateTime'] = pd.to_datetime(ls_df['date'] + ' ' + ls_df['endTime'])
+            return ls_df
+        else:
+            print(f"The loadshift file '{full_ls_filename}' does not exist. Thus loadshifting will not be added to daily dataframe.")
+            return pd.DataFrame()

{ecopipeline-1.0.4.dist-info → ecopipeline-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecopipeline
-Version: 1.0.4
+Version: 1.1.0
 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.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+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=OeNwxJ9uWZLJjtpm9_qzVpRRaqyPKjn39WlW4SpzDYE,62062
+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=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.1.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ecopipeline-1.1.0.dist-info/METADATA,sha256=igrtMpk3zjLaGqZZnup-AGQK2zyVAta1wufec-YgB-E,2363
+ecopipeline-1.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ecopipeline-1.1.0.dist-info/top_level.txt,sha256=WOPFJH2LIgKqm4lk2OnFF5cgVkYibkaBxIxgvLgO7y0,12
+ecopipeline-1.1.0.dist-info/RECORD,,

{ecopipeline-1.0.4.dist-info → ecopipeline-1.1.0.dist-info}/WHEEL

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

ecopipeline-1.0.4.dist-info/RECORD

@@ -1,25 +0,0 @@
-ecopipeline/__init__.py,sha256=pjC00JWsjVAhS0jUKHD-wyi4UIpTsWbIg9JaxLS1mlc,275
-ecopipeline/event_tracking/__init__.py,sha256=1saCNVWbcp7bwz1kXfKa2d8aUoGWNWvWSj7IJY4fzc8,219
-ecopipeline/event_tracking/event_tracking.py,sha256=LASkal4MgGLN7UzrAjbKw3eaM9JwKwt3YpkIraRSgiE,51172
-ecopipeline/extract/__init__.py,sha256=j_8-q_yrPRySwYyloMv5v2XQeYYyYfX0N-MW2ZDA4rg,775
-ecopipeline/extract/extract.py,sha256=MykzAchL_0LY0NG9TOAadpm5MSgjn7lPRI8AvSIMUBk,58530
-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=TaWFD7mrcTuLX-hmV8klyMFKFfEjzJI21FLkY37fjkY,57254
-ecopipeline/utils/ConfigManager.py,sha256=_9MZE9S-wOlQboAHzVk7VSrtxqR_lLu1hVJ-iulp4ag,13174
-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.4.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ecopipeline-1.0.4.dist-info/METADATA,sha256=wE8t_wMfNclwSkN2kFK5mqazOXqvuI2VHqfMgrK1CxU,2363
-ecopipeline-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ecopipeline-1.0.4.dist-info/top_level.txt,sha256=WOPFJH2LIgKqm4lk2OnFF5cgVkYibkaBxIxgvLgO7y0,12
-ecopipeline-1.0.4.dist-info/RECORD,,