py-ewr 2.0.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

py_ewr/scenario_handling.py

@@ -16,31 +16,29 @@ log.addHandler(logging.NullHandler())
 from . import data_inputs, evaluate_EWRs, summarise_results
 #----------------------------------- Scenario testing handling functions--------------------------#
 
-def unpack_IQQM_10000yr(csv_file: str) -> pd.DataFrame:
-    '''Ingesting scenario file locations with the NSW specific format for 10,000 year flow timeseries
-    returns a dictionary of flow dataframes with their associated header data
+# def gauge_only_column(df: pd.DataFrame) -> pd.DataFrame:
+#     '''Ingesting scenario file locations with a standard timeseries format,
+#     returns a dictionary of flow dataframes with their associated header data
     
-    Args:
-        csv_file (str): location of model file
-
-    Results:
-        pd.DataFrame: model file converted to dataframe 
+#     Args:
+#         csv_file (str): location of model file
 
-    '''
+#     Results:
+#         pd.DataFrame: model file converted to dataframe
+#     '''
     
-    df = pd.read_csv(csv_file, index_col = 'Date')
-    siteList = []
-    for location in df.columns:
-        gauge = extract_gauge_from_string(location)
-        siteList.append(gauge)
-    # Save over the top of the column headings with the new list containing only the gauges
-    df.columns = siteList
+#     siteList = []
+#     for location in df.columns:
+#         gauge = extract_gauge_from_string(location)
+#         siteList.append(gauge)
+#     # Save over the top of the column headings with the new list containing only the gauges
+#     df.columns = siteList
     
-    return df
+#     return df
     
 
 def unpack_model_file(csv_file: str, main_key: str, header_key: str) -> tuple:
-    '''Ingesting scenario file locations of model files with all formats (excluding NSW 10,000 year), seperates the flow data and header data
+    '''Ingesting scenario file locations of model files with all formats (excluding standard timeseries format), seperates the flow data and header data
     returns a dictionary of flow dataframes with their associated header data
     
     Args:
@@ -67,6 +65,7 @@ def unpack_model_file(csv_file: str, main_key: str, header_key: str) -> tuple:
         for row in cr:
             if row[0].startswith(line):
                 headerVal = pos
+                break
             pos = pos + 1
         if main_key == 'Dy':
             df = pd.read_csv(url, header=headerVal, dtype={'Dy':'int', 'Mn': 'int', 'Year': 'int'}, skiprows=range(headerVal+1, headerVal+2))
@@ -86,6 +85,7 @@ def unpack_model_file(csv_file: str, main_key: str, header_key: str) -> tuple:
             for row in csv_reader:
                 if row[0].startswith(line):
                     headerVal = line_count
+                    break
                 line_count = line_count + 1
         if main_key == 'Dy':
             df = pd.read_csv(file, header=headerVal, dtype={'Dy':'int', 'Mn': 'int', 'Year': 'int'}, skiprows=range(headerVal+1, headerVal+2))
@@ -106,6 +106,7 @@ def unpack_model_file(csv_file: str, main_key: str, header_key: str) -> tuple:
         for row in cr:
             if row[0].startswith(line):
                 headerVal = pos
+                break
             pos = pos + 1
         junkRows = headerVal # Junk rows because rows prior to this value will be discarded
         df = pd.read_csv(url, header=headerVal, nrows = (endLine-junkRows-1), dtype={'Site':'str', 'Measurand': 'str', 'Quality': 'str'})
@@ -124,9 +125,9 @@ def unpack_model_file(csv_file: str, main_key: str, header_key: str) -> tuple:
             for row in csv_reader:
                 if row[0].startswith(line):
                     headerVal = line_count
-                    
                     # Then get column length:
                     num_cols = num_cols = list(range(0,len(row),1))
+                    break
                     
                 line_count = line_count + 1
             junkRows = headerVal # Junk rows because rows prior to this value will be discarded
@@ -246,7 +247,7 @@ def cleaner_NSW(input_df: pd.DataFrame) -> pd.DataFrame:
     
     return cleaned_df
 
-def cleaner_IQQM_10000yr(input_df: pd.DataFrame, ewr_table_path: str = None) -> pd.DataFrame:
+def cleaner_standard_timeseries(input_df: pd.DataFrame, ewr_table_path: str = None) -> pd.DataFrame:
     '''Ingests dataframe, removes junk columns, fixes date, allocates gauges to either flow/level
     
     Args:
@@ -274,37 +275,31 @@ def cleaner_IQQM_10000yr(input_df: pd.DataFrame, ewr_table_path: str = None) ->
     date_range = pd.period_range(date_start, date_end, freq = 'D')
     cleaned_df['Date'] = date_range
     cleaned_df = cleaned_df.set_index('Date')
-    
-    # Split gauges into flow and level, allocate to respective dataframe
-    flow_gauges = data_inputs.get_gauges('flow gauges',ewr_table_path)
-    level_gauges = data_inputs.get_gauges('level gauges', ewr_table_path)
+
     df_flow = pd.DataFrame(index = cleaned_df.index)
     df_level = pd.DataFrame(index = cleaned_df.index)
+
     for gauge in cleaned_df.columns:
-        if gauge in flow_gauges:
-            df_flow[gauge] = cleaned_df[gauge].copy(deep=True)
-        if gauge in level_gauges:
-            df_level[gauge] = cleaned_df[gauge].copy(deep=True)
+        gauge_only = extract_gauge_from_string(gauge)
+        if 'flow' in gauge:
+            df_flow[gauge_only] = cleaned_df[gauge].copy(deep=True)
+        if 'level' in gauge:
+            df_level[gauge_only] = cleaned_df[gauge].copy(deep=True)
+        if not gauge_only:
+            log.info('Could not identify gauge in column name:', gauge, ', skipping analysis of data in this column.')
     return df_flow, df_level
 
 def extract_gauge_from_string(input_string: str) -> str:
-    '''Takes in a string, pulls out the gauge number from this string
+    '''Takes in a strings, pulls out the gauge number from this string
     
     Args:
         input_string (str): string which may contain a gauge number
 
     Returns:
         str: Gauge number as a string if found, None if not found
-    
     '''
-    found = re.findall(r'\w+\d+\w', input_string)
-    if found:
-        for i in found:
-            if len(i) >= 6:
-                gauge = i
-                return gauge
-    else:
-        return None
+    gauge = input_string.split('_')[0]
+    return gauge
 
 def match_MDBA_nodes(input_df: pd.DataFrame, model_metadata: pd.DataFrame, ewr_table_path: str) -> tuple:
     '''Checks if the source file columns have EWRs available, returns a flow and level dataframe with only 
@@ -372,12 +367,10 @@ def any_cllmm_to_process(gauge_results: dict)->bool:
 
 class ScenarioHandler:
     
-    def __init__(self, scenario_files: List[str], model_format:str, allowance:Dict, climate:str, parameter_sheet:str = None,
+    def __init__(self, scenario_file: str, model_format:str, parameter_sheet:str = None,
                 calc_config_path:str = None):
-        self.scenario_files = scenario_files
+        self.scenario_file = scenario_file
         self.model_format = model_format
-        self.allowance = allowance
-        self.climate = climate
         self.yearly_events = None
         self.pu_ewr_statistics = None
         self.summary_results = None
@@ -389,16 +382,21 @@ class ScenarioHandler:
     def _get_file_names(self, loaded_files):
 
         file_locations = {}
-        for file in loaded_files:
-            full_name = file.split('/')
-            name_exclude_extension = full_name[-1].split('.csv')[0]
-            file_locations[str(name_exclude_extension)] = file
+        # for file in loaded_files:
+        if '/' in loaded_files:
+            full_name = loaded_files.split('/')
+        elif ('\\' in loaded_files):
+            full_name = loaded_files.split('\\')
+        else:
+            full_name = loaded_files
+        name_exclude_extension = full_name[-1].split('.csv')[0]
+        file_locations[str(name_exclude_extension)] = loaded_files
             
         return file_locations
         
     def process_scenarios(self):
 
-        scenarios = self._get_file_names(self.scenario_files)
+        scenarios = self._get_file_names(self.scenario_file)
 
         # Analyse all scenarios for EWRs
         detailed_results = {}
@@ -406,16 +404,15 @@ class ScenarioHandler:
         for scenario in tqdm(scenarios, position = 0, leave = True, 
                             bar_format='{l_bar}{bar:10}{r_bar}{bar:-10b}',
                             desc= 'Evaluating scenarios'):
-        
             if self.model_format == 'Bigmod - MDBA':
                 data, header = unpack_model_file(scenarios[scenario], 'Dy', 'Field')
                 data = build_MDBA_columns(data, header)
                 df_clean = cleaner_MDBA(data)
                 df_F, df_L = match_MDBA_nodes(df_clean, data_inputs.get_MDBA_codes(), self.parameter_sheet)
 
-            elif self.model_format == 'IQQM - NSW 10,000 years':
-                df_unpacked = unpack_IQQM_10000yr(scenarios[scenario])
-                df_F, df_L = cleaner_IQQM_10000yr(df_unpacked, self.parameter_sheet)
+            elif self.model_format == 'Standard time-series':
+                df = pd.read_csv(scenarios[scenario], index_col = 'Date')
+                df_F, df_L = cleaner_standard_timeseries(df, self.parameter_sheet)
 
             elif self.model_format == 'Source - NSW (res.csv)':
                 data, header = unpack_model_file(scenarios[scenario], 'Date', 'Field')
@@ -429,20 +426,18 @@ class ScenarioHandler:
             EWR_table, bad_EWRs = data_inputs.get_EWR_table(self.parameter_sheet)
             calc_config = data_inputs.get_ewr_calc_config(self.calc_config_path)
             for gauge in all_locations:
-                gauge_results[gauge], gauge_events[gauge] = evaluate_EWRs.calc_sorter(df_F, df_L, gauge, self.allowance, self.climate, 
-                                                                                        EWR_table, calc_config)
-        
+                gauge_results[gauge], gauge_events[gauge] = evaluate_EWRs.calc_sorter(df_F, df_L, gauge,
+                                                                                        EWR_table, calc_config) 
             detailed_results[scenario] = gauge_results
-            
+            #print(detailed_results)
             detailed_events[scenario] = gauge_events
-
+            #print(detailed_events)
             self.pu_ewr_statistics = detailed_results
             self.yearly_events = detailed_events
             
             self.flow_data = df_F
             self.level_data = df_L
 
-
     def get_all_events(self)-> pd.DataFrame:
 
         if not self.yearly_events:
@@ -561,7 +556,7 @@ class ScenarioHandler:
         yearly_ewr_results = summarise_results.join_ewr_parameters(cols_to_add=['Multigauge'],
                                 left_table=yearly_ewr_results,
                                 left_on=['gauge','pu','ewrCode'],
-                                selected_columns= ['Year', 'eventYears', 'numAchieved', 'numEvents', 'numEventsAll', #'maxInterEventDays', 'maxInterEventDaysAchieved',
+                                selected_columns= ['Year', 'eventYears', 'numAchieved', 'numEvents', 'numEventsAll',
                                              'eventLength', 'eventLengthAchieved', 'totalEventDays', 'totalEventDaysAchieved',
                                             'maxEventDays', 'maxRollingEvents', 'maxRollingAchievement',
                                             'missingDays', 'totalPossibleDays', 'ewrCode',

py_ewr/summarise_results.py

@@ -630,7 +630,7 @@ def get_rolling_max_interEvents(df:pd.DataFrame, start_date: date, end_date: dat
             master_dict[scenario][gauge][pu] = {}
         if ewr not in master_dict[scenario][gauge][pu]:
             master_dict[scenario][gauge][pu][ewr] = evaluate_EWRs.construct_event_dict(unique_years)
-        # Pull EWR start and end date from EWR dataset and clean TODO: functionalise this
+        # Pull EWR start and end date from EWR dataset and clean
         EWR_info = {}
         EWR_info['start_date'] = data_inputs.ewr_parameter_grabber(EWR_table, gauge, pu, ewr, 'StartMonth')
         EWR_info['end_date'] = data_inputs.ewr_parameter_grabber(EWR_table, gauge, pu, ewr, 'EndMonth')
@@ -647,8 +647,6 @@ def get_rolling_max_interEvents(df:pd.DataFrame, start_date: date, end_date: dat
         else:
             EWR_info['end_day'] = None
             EWR_info['end_month'] =int(EWR_info['end_date'])        
-        # if ewr == "LF2_WP":
-        # if unique_EWR == "big10602.bmdTEMPORARY_ID_SPLIT425010TEMPORARY_ID_SPLITMurray River - Lock 10 to Lock 9TEMPORARY_ID_SPLITLF2_WP":
 
         # Iterate over the interevent periods for this EWR
         for i, row in df_subset.iterrows():

py_ewr-2.1.2.dist-info/METADATA

@@ -0,0 +1,222 @@
+Metadata-Version: 2.1
+Name: py_ewr
+Version: 2.1.2
+Summary: Environmental Water Requirement calculator
+Home-page: https://github.com/MDBAuth/EWR_tool
+Author: Martin Job
+Author-email: Martin.Job@mdba.gov.au
+Project-URL: Bug Tracker, https://github.com/MDBAuth/EWR_tool/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License (GPL)
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Framework :: Pytest
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ipython ==8.8.0
+Requires-Dist: ipywidgets ==7.7.0
+Requires-Dist: pandas ==2.0.3
+Requires-Dist: requests ==2.25.1
+Requires-Dist: tqdm ==4.64.0
+Requires-Dist: mdba-gauge-getter ==0.5.1
+Requires-Dist: cachetools ==5.2.0
+
+[![CI](https://github.com/MDBAuth/EWR_tool/actions/workflows/test-release.yml/badge.svg)]()
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/py-ewr)](https://pypi.org/project/py-ewr/)
+[![PyPI](https://img.shields.io/pypi/v/py-ewr)](https://pypi.org/project/py-ewr/)
+[![DOI](https://zenodo.org/badge/342122359.svg)](https://zenodo.org/badge/latestdoi/342122359)
+
+### **EWR tool version 2.1.2 README**
+
+### **Notes on recent updates**
+- Ability to pass a climte categorisation file has been removed. No EWRs require climate categorisation anymore so this feature was redundant.
+- Ability to pass an allowance on some parts of the parameter sheet. This feature was not transparent and resulted in some counter-intuitive results in many cases so the feature has been removed during this update. If users are interested in assessing partial success through an allowance feature we recommend downloading the parameter sheet, making the required modifications (e.g. multiplying the duration column by a factor of 0.9 to simulate a 10% allowance), and running the EWR tool with this.
+- Ability to pass multiple model scenarios to the package has been removed. It is recommended to use an alternative method if you want to send multiple scenarios to the package. An example has been provided below by calling the EWR tool package in a loop. This has been implemented because some scenarios may have multiple different files and this was the cleanest way to account for this.
+
+### **Installation**
+
+Note - requires Python 3.8 or newer
+
+Step 1. 
+Upgrade pip
+```bash
+python -m pip install –-upgrade pip
+```
+
+Step 2.
+```bash
+pip install py-ewr
+``` 
+
+### Option 1: Running the observed mode of the tool
+The EWR tool will use a second program called gauge getter to first download the river data at the locations and dates selected and then run this through the EWR tool
+
+```python
+
+from datetime import datetime
+
+#USER INPUT REQUIRED>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+dates = {'start_date': datetime(YYYY, 7, 1), 
+        'end_date': datetime(YYYY, 6, 30)}
+
+gauges = ['Gauge1', 'Gauge2']
+
+# END USER INPUT<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+```
+
+```python
+
+from py_ewr.observed_handling import ObservedHandler
+
+# Running the EWR tool:
+ewr_oh = ObservedHandler(gauges=gauges, dates=dates)
+
+# Generating tables:
+# Table 1: Summarised EWR results for the entire timeseries
+ewr_results = ewr_oh.get_ewr_results()
+
+# Table 2: Summarised EWR results, aggregated to water years:
+yearly_ewr_results = ewr_oh.get_yearly_ewr_results()
+
+# Table 3: All events details regardless of duration 
+all_events = ewr_oh.get_all_events()
+
+# Table 4: Inverse of Table 3 showing the interevent periods
+all_interEvents = ewr_oh.get_all_interEvents()
+
+# Table 5: All events details that also meet the duration requirement:
+all_successfulEvents = ewr_oh.get_all_successful_events()
+
+# Table 6: Inverse of Table 5 showing the interevent periods:
+all_successful_interEvents = ewr_oh.get_all_successful_interEvents()
+
+```
+
+### Option 2: Running model scenarios through the EWR tool
+
+1. Tell the tool where the model files are (can either be local or in a remote location)
+2. Tell the tool what format the model files are in (Current model format options: 'Bigmod - MDBA', 'Source - NSW (res.csv)', 'IQQM - NSW 10,000 years' - see manual for formatting requirements)
+
+```python
+#USER INPUT REQUIRED>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+# Minimum 1 scenario and 1 related file required
+scenarios = {'Scenario1': ['file/location/1', 'file/location/2', 'file/location/3'],
+             'Scenario2': ['file/location/1', 'file/location/2', 'file/location/3']}
+
+model_format = 'Bigmod - MDBA'
+
+# END USER INPUT<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+```
+
+``` python
+from py_ewr.scenario_handling import ScenarioHandler
+import pandas as pd
+
+ewr_results_dict = {}
+yearly_results_dict = {}
+all_events_dict = {}
+all_interEvents_dict = {}
+all_successful_Events_dict = {}
+all_successful_interEvents_dict = {}
+
+for scenario_name, scenario_list in scenarios.items():
+    ewr_results = pd.DataFrame()
+    yearly_ewr_results = pd.DataFrame()
+    all_events = pd.DataFrame()
+    all_interEvents = pd.DataFrame()
+    all_successful_Events = pd.DataFrame()
+    all_successful_interEvents = pd.DataFrame()
+    for file in scenarios[scenario_name]:
+
+        # Running the EWR tool:
+        ewr_sh = ScenarioHandler(scenario_file = file, 
+                                model_format = model_format)
+
+        # Return each table and stitch the different files of the same scenario together:
+        # Table 1: Summarised EWR results for the entire timeseries
+        temp_ewr_results = ewr_sh.get_ewr_results()
+        ewr_results = pd.concat([ewr_results, temp_ewr_results], axis = 0)
+        # Table 2: Summarised EWR results, aggregated to water years:
+        temp_yearly_ewr_results = ewr_sh.get_yearly_ewr_results()
+        yearly_ewr_results = pd.concat([yearly_ewr_results, temp_yearly_ewr_results], axis = 0)
+        # Table 3: All events details regardless of duration 
+        temp_all_events = ewr_sh.get_all_events()
+        all_events = pd.concat([all_events, temp_all_events], axis = 0)
+        # Table 4: Inverse of Table 3 showing the interevent periods
+        temp_all_interEvents = ewr_sh.get_all_interEvents()
+        all_interEvents = pd.concat([all_interEvents, temp_all_interEvents], axis = 0)
+        # Table 5: All events details that also meet the duration requirement:
+        temp_all_successfulEvents = ewr_sh.get_all_successful_events()
+        all_successful_Events = pd.concat([all_successful_Events, temp_all_successfulEvents], axis = 0)
+        # Table 6: Inverse of Table 5 showing the interevent periods:
+        temp_all_successful_interEvents = ewr_sh.get_all_successful_interEvents()
+        all_successful_interEvents = pd.concat([all_successful_interEvents, temp_all_successful_interEvents], axis = 0)
+        
+
+    # Optional code to output results to csv files:
+    ewr_results.to_csv(scenario_name + 'all_results.csv')
+    yearly_ewr_results.to_csv(scenario_name + 'yearly_ewr_results.csv')
+    all_events.to_csv(scenario_name + 'all_events.csv')
+    all_interEvents.to_csv(scenario_name + 'all_interevents.csv')
+    all_successful_Events.to_csv(scenario_name + 'all_successful_Events.csv')
+    all_successful_interEvents.to_csv(scenario_name + 'all_successful_interEvents.csv')
+
+    # Save the final tables to the dictionaries:   
+    ewr_results_dict[scenario_name] = ewr_results
+    yearly_results_dict[scenario_name] = yearly_ewr_results
+    all_events_dict[scenario_name] = all_events_dict
+    all_interEvents_dict[scenario_name] = all_interEvents
+    all_successful_Events_dict[scenario_name] = all_successful_Events
+    all_successful_interEvents_dict[scenario_name] = all_successful_interEvents
+
+
+```
+
+
+### **Purpose**
+This tool has two purposes:
+1. Operational: Tracking EWR success at gauges of interest in real time - option 1 above.
+2. Planning: Comparing EWR success between scenarios (i.e. model runs) - option 2 above.
+
+**Support**
+For issues relating to the script, a tutorial, or feedback please contact Lara Palmer at lara.palmer@mdba.gov.au, Martin Job at martin.job@mdba.gov.au, or Joel Bailey at joel.bailey@mdba.gov.au
+
+
+**Disclaimer**
+Every effort has been taken to ensure the EWR database represents the original EWRs from state long term water plans as best as possible, and that the code within this tool has been developed to interpret and analyse these EWRs in an accurate way. However, there may still be unresolved bugs in the EWR parameter sheet and/or EWR tool. Please report any bugs to the issues tab under the GitHub project so we can investigate further. 
+
+
+**Notes on development of the dataset of EWRs**
+The MDBA has worked with Basin state representatives to ensure scientific integrity of EWRs has been maintained when translating from raw EWRs in the Basin state Long Term Water Plans (LTWPs) to the machine readable format found in the parameter sheet within this tool. 
+
+**Compatibility**
+
+NSW:
+- All Queensland catchments
+- All New South Wales catchments
+- All South Australian catchments
+- All EWRs from river based Environmental Water Management Plans (EWMPs) in Victoria*
+
+*Currently the wetland EWMPS and mixed wetland-river EWMPs in Victoria contain EWRs that cannot be evaluated by an automated EWR tool so the EWRs from these plans have been left out for now. The MDBA will work with our Victorian colleagues to ensure any updated EWRs in these plans are integrated into the tool where possible.
+
+**Input data**
+
+- Gauge data from the relevant Basin state websites and the Bureau of Meteorology website
+- Scenario data input by the user
+- Model metadata for location association between gauge ID's and model nodes
+- EWR parameter sheet
+
+**Running the tool**
+
+Consult the user manual for instructions on how to run the tool. Please email the above email addresses for a copy of the user manual.
+

py_ewr-2.1.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+py_ewr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_ewr/data_inputs.py,sha256=BLJrrasZYpSUkC0yVBzVqnz6WGT2Y3SJYJJhguDi-Vo,18046
+py_ewr/evaluate_EWRs.py,sha256=1JYWNtw5MYgf92jXhDNlgGkDx2mcfBP34OO-0jgal1w,229279
+py_ewr/observed_handling.py,sha256=NaySsqe8nWgZdDRSr22EYmCwf0uNzVj9DFF6hzNr6ws,18173
+py_ewr/scenario_handling.py,sha256=QfUTpFr4uylTcoIDEjQJi2YZfydQR1I0ayorGJKFNkk,26399
+py_ewr/summarise_results.py,sha256=4IsRBfWP6XQvLRU2TUrY8lIGwlD1JMpmbEkbIWUaE4k,29787
+py_ewr/model_metadata/SiteID_MDBA.csv,sha256=OR2fUIwU8ei85Nq6nZxb_ozC4q9scATrnqED21PlGRM,162848
+py_ewr/model_metadata/SiteID_NSW.csv,sha256=UVBxN43Z5KWCvWhQ5Rh6TNEn35q4_sjPxKyHg8wPFws,6805
+py_ewr/parameter_metadata/ewr_calc_config.json,sha256=BkuSJI6NqZzJxZMd8eh3GBs5uoHfI2joOkPrKLu9-60,17556
+py_ewr/parameter_metadata/parameter_sheet.csv,sha256=ufOYn59cS4kl9XF1WaNqBhodcsBxUWH8Y0g1qHVUAcg,594257
+py_ewr-2.1.2.dist-info/LICENSE,sha256=ogEPNDSH0_dhiv_lT3ifVIdgIzHAqNA_SemnxUfPBJk,7048
+py_ewr-2.1.2.dist-info/METADATA,sha256=a-gfT0nKlAbWRwRSx9GMnjo4GQocz4LctPEatn9eE_4,10070
+py_ewr-2.1.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+py_ewr-2.1.2.dist-info/top_level.txt,sha256=n3725d-64Cjyb-YMUMV64UAuIflzUh2_UZSxiIbrur4,7
+py_ewr-2.1.2.dist-info/RECORD,,

{py_ewr-2.0.0.dist-info → py_ewr-2.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any